@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-Q2Y3VMKH.js

@@ -0,0 +1,2000 @@
+'use strict';
+
+var chunkWOF3AD3J_js = require('./chunk-WOF3AD3J.js');
+var chunkOMTVH334_js = require('./chunk-OMTVH334.js');
+var chunkUCR5HRYM_js = require('./chunk-UCR5HRYM.js');
+var sha2_js = require('@noble/hashes/sha2.js');
+
+// 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, DEFAULT_MAX_POLL_ATTEMPTS = 60, DEFAULT_MAX_ACTION_STEPS = 4, DEFAULT_MAX_TERMS_REVIEW_STEPS = 4, DEFAULT_DEADLINE_MS = (3e3) * (60), TRANSIENT_RETRY_BASE_MS = 1e3, TRANSIENT_RETRY_MAX_MS = 8e3, HTTP_SERVER_ERROR_PREFIX = "HTTP_5", TRANSIENT_ERROR_CODES = /* @__PURE__ */ new Set([
+  chunkUCR5HRYM_js.ErrorCode.NETWORK_ERROR,
+  chunkUCR5HRYM_js.ErrorCode.TIMEOUT,
+  chunkUCR5HRYM_js.ErrorCode.SERVER_ERROR
+]), PROVIDER_OWNED_ACTIONS = /* @__PURE__ */ new Set([
+  chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.REDIRECT_REQUIRED,
+  chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED
+]);
+function nonnegativeInteger(value, fallback) {
+  return value === void 0 || !Number.isFinite(value) ? fallback : Math.max(0, Math.floor(value));
+}
+function isTransientPurchaseIntentError(error) {
+  return error.retryable || TRANSIENT_ERROR_CODES.has(error.code) || error.code.startsWith(HTTP_SERVER_ERROR_PREFIX);
+}
+function transientRetryDelay(attempt) {
+  return Math.min((1e3) * 2 ** Math.max(0, attempt - 1), (8e3));
+}
+function abortError() {
+  let error = new Error("Purchase-intent resolution was cancelled.");
+  return error.name = "AbortError", error;
+}
+async function abortableWait(milliseconds, signal) {
+  if (signal?.aborted) throw abortError();
+  milliseconds <= 0 || await new Promise((resolve, reject) => {
+    let timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort), resolve();
+    }, milliseconds), 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, this.now = dependencies.now ?? Date.now;
+  }
+  async resolve(intentId, options) {
+    let pollIntervalMs = nonnegativeInteger(
+      options.pollIntervalMs,
+      (3e3)
+    ), maxPollAttempts = nonnegativeInteger(
+      options.maxPollAttempts,
+      (60)
+    ), maxActionSteps = nonnegativeInteger(options.maxActionSteps, (4)), maxTermsReviewSteps = nonnegativeInteger(
+      options.maxTermsReviewSteps,
+      (4)
+    ), deadline = this.now() + nonnegativeInteger(options.deadlineMs, DEFAULT_DEADLINE_MS), request = options.confirmation, pollAttempts = 0, actionSteps = 0, termsReviewSteps = 0, transientAttempts = 0, lastResponse = null, handedOverAction = null, requestOptions = { signal: options.signal, timeoutMs: options.requestTimeoutMs };
+    this.ensureActive(options.signal), this.notify(options, chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.CONFIRMING);
+    let responseResult = options.initialResponse ? chunkOMTVH334_js.ok(options.initialResponse) : await this.confirmation.confirm(intentId, request, requestOptions);
+    for (; ; ) {
+      if (this.ensureActive(options.signal), !responseResult.ok) {
+        let remaining = deadline - this.now();
+        if (!isTransientPurchaseIntentError(responseResult.error) || remaining <= 0)
+          return remaining <= 0 && lastResponse?.status === chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.COLLECTION_PROCESSING ? chunkOMTVH334_js.ok({ kind: chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.TIMED_OUT, response: lastResponse }) : responseResult;
+        transientAttempts += 1, this.notify(options, chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.RECONNECTING, lastResponse ?? void 0), await this.wait(Math.min(transientRetryDelay(transientAttempts), remaining), options.signal), responseResult = await this.confirmation.confirm(intentId, request, requestOptions);
+        continue;
+      }
+      transientAttempts = 0;
+      let response = responseResult.value;
+      switch (lastResponse = response, response.status) {
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.ORDER_CREATED:
+          return this.notify(options, chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.COMPLETED, response), chunkOMTVH334_js.ok({ kind: chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.COMPLETED, response });
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_FAILED:
+          return this.notify(options, chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.FAILED, response), chunkOMTVH334_js.ok({ kind: chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.FAILED, response });
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_OUTCOME_UNKNOWN:
+          return this.notify(options, chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.OUTCOME_UNKNOWN, response), chunkOMTVH334_js.ok({ kind: chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.OUTCOME_UNKNOWN, response });
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.COLLECTION_PROCESSING:
+          if (pollAttempts >= maxPollAttempts)
+            return chunkOMTVH334_js.ok({ kind: chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.TIMED_OUT, response });
+          pollAttempts += 1, this.notify(options, chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.POLLING, response), await this.wait(pollIntervalMs, options.signal), responseResult = await this.confirmation.confirm(intentId, request, requestOptions);
+          continue;
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.REDIRECT_REQUIRED:
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED:
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.AUTHORIZATION_REQUIRED: {
+          this.notify(options, chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.AWAITING_ACTION, response);
+          let actionKey = `${response.attempt_id}:${response.status}`;
+          if (actionKey === handedOverAction) {
+            if (pollAttempts >= maxPollAttempts)
+              return chunkOMTVH334_js.ok({ kind: chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.ACTION_REQUIRED, response });
+            pollAttempts += 1, await this.wait(pollIntervalMs, options.signal), responseResult = await this.confirmation.confirm(intentId, request, requestOptions);
+            continue;
+          }
+          if (!options.onActionRequired || actionSteps >= maxActionSteps)
+            return chunkOMTVH334_js.ok({ kind: chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.ACTION_REQUIRED, response });
+          actionSteps += 1;
+          let decision = await options.onActionRequired(response);
+          if (decision === chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.STOP)
+            return chunkOMTVH334_js.ok({ kind: chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.ACTION_REQUIRED, response });
+          if (typeof decision == "object" && decision.kind === chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.SUBMIT) {
+            if (!this.confirmation.submitAction)
+              return chunkOMTVH334_js.err(
+                new chunkUCR5HRYM_js.CimplifyError(
+                  chunkUCR5HRYM_js.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,
+              requestOptions
+            );
+            continue;
+          }
+          if (decision !== chunkUCR5HRYM_js.PURCHASE_INTENT_ACTION_DECISION.CONTINUE)
+            return chunkOMTVH334_js.err(
+              new chunkUCR5HRYM_js.CimplifyError(
+                chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.ACTION_UNSUPPORTED,
+                "The action callback returned an unsupported decision.",
+                false
+              )
+            );
+          PROVIDER_OWNED_ACTIONS.has(response.status) && (handedOverAction = actionKey), await this.wait(pollIntervalMs, options.signal), responseResult = await this.confirmation.confirm(intentId, request, requestOptions);
+          continue;
+        }
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.TERMS_CHANGED: {
+          if (this.notify(options, chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLVE_STATUS.REVIEWING_TERMS, response), !options.onTermsChanged || termsReviewSteps >= maxTermsReviewSteps)
+            return chunkOMTVH334_js.ok({ kind: chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.REVIEW_REQUIRED, response });
+          termsReviewSteps += 1;
+          let replacementRequest = await options.onTermsChanged(response);
+          if (!replacementRequest)
+            return chunkOMTVH334_js.ok({ kind: chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.REVIEW_REQUIRED, response });
+          request = replacementRequest, responseResult = await this.confirmation.confirm(intentId, request, requestOptions);
+          continue;
+        }
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.SELECTION_UNAVAILABLE:
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.OFFER_ENDED:
+        case chunkUCR5HRYM_js.PURCHASE_INTENT_CONFIRM_STATUS.SOURCE_UNAVAILABLE:
+          return chunkOMTVH334_js.ok({ kind: chunkUCR5HRYM_js.PURCHASE_INTENT_RESOLUTION_KIND.REVIEW_REQUIRED, response });
+        default:
+          return chunkOMTVH334_js.err(
+            new chunkUCR5HRYM_js.CimplifyError(
+              chunkUCR5HRYM_js.PURCHASE_INTENT_ERROR_CODE.ACTION_UNSUPPORTED,
+              "The payment returned a status this checkout does not understand.",
+              false
+            )
+          );
+      }
+    }
+  }
+  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) {
+  let normalized = intentId.trim();
+  if (!normalized) throw new TypeError("intentId must not be empty");
+  return `${PURCHASE_INTENT_ROUTE.DIRECT_COLLECTION}/${encodeURIComponent(normalized)}`;
+}
+function hostedSessionPath(sessionId) {
+  let 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 chunkOMTVH334_js.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 chunkOMTVH334_js.safe(
+      this.transport.get(this.intentPath(intentId), {
+        signal: options?.signal,
+        timeoutMs: options?.timeoutMs
+      })
+    );
+  }
+  refresh(intentId, expectedRevision, options) {
+    let request = {
+      expected_intent_revision: expectedRevision
+    };
+    return chunkOMTVH334_js.safe(
+      this.transport.post(
+        `${this.intentPath(intentId)}/${PURCHASE_INTENT_ROUTE.REFRESH}`,
+        request,
+        {
+          signal: options?.signal,
+          timeoutMs: options?.timeoutMs
+        }
+      )
+    );
+  }
+  confirm(intentId, request, options) {
+    return chunkOMTVH334_js.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) {
+    let normalizedAttemptId = attemptId.trim();
+    if (!normalizedAttemptId) throw new TypeError("attemptId must not be empty");
+    return chunkOMTVH334_js.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);
+  }
+}, HostedPurchaseIntentService = class {
+  constructor(transport, sessionId) {
+    this.transport = transport;
+    this.sessionPath = hostedSessionPath(sessionId), this.resolver = new PurchaseIntentResolver({ confirmation: this });
+  }
+  prepare(request, options) {
+    return chunkOMTVH334_js.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 chunkOMTVH334_js.safe(
+      this.transport.post(
+        `${this.sessionPath}/${PURCHASE_INTENT_ROUTE.CONFIRM}`,
+        request,
+        {
+          idempotencyKey: request.idempotency_key,
+          signal: options?.signal,
+          timeoutMs: options?.timeoutMs
+        }
+      )
+    );
+  }
+  replay(options) {
+    return chunkOMTVH334_js.safe(
+      this.transport.get(
+        `${this.sessionPath}/${PURCHASE_INTENT_ROUTE.REPLAY}`,
+        {
+          signal: options?.signal,
+          timeoutMs: options?.timeoutMs
+        }
+      )
+    );
+  }
+  submitAction(_intentId, attemptId, request, options) {
+    let normalized = attemptId.trim();
+    if (!normalized) throw new TypeError("attemptId must not be empty");
+    return chunkOMTVH334_js.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 {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * The shopper's available store-credit balance, in the business's default
+   * currency. Requires a signed-in customer; returns an error otherwise.
+   */
+  async balance() {
+    return chunkOMTVH334_js.safe(this.client.get("/api/v1/store-credit/balance"));
+  }
+};
+
+// src/internal/analytics-session.ts
+var ANALYTICS_SESSION_STORAGE_KEY_PREFIX = "cimplify_analytics_session:v2:";
+var AnalyticsSessionCoordinator = class {
+  constructor(identity) {
+    this.identity = identity;
+    this.fallbackState = null;
+  }
+  beginEvent(nowMs = Date.now()) {
+    let state = this.resolveActiveState(nowMs);
+    state.lastActivityAtMs = nowMs;
+    let occurredAt = reserveOccurredAt(state, nowMs, 1);
+    return this.write(state), toEventContext(state, occurredAt);
+  }
+  beginPage(path, nowMs = Date.now()) {
+    let existing = this.read(), expired = !existing || isExpired(existing, nowMs), state = expired ? newSession(nowMs) : existing, previousPage = expired ? void 0 : durationFor(state.activePage, nowMs);
+    state.lastActivityAtMs = nowMs, state.activePage = { path, enteredAtMs: nowMs };
+    let occurredAt = reserveOccurredAt(state, nowMs, previousPage ? 2 : 1);
+    return this.write(state), {
+      session: toEventContext(state, occurredAt),
+      previousPage
+    };
+  }
+  current() {
+    let state = this.read();
+    return !state || isExpired(state, Date.now()) ? null : toContext(state);
+  }
+  markBootstrapped(sessionId) {
+    let state = this.read();
+    !state || state.id !== sessionId || (state.bootstrapped = true, this.write(state));
+  }
+  reset() {
+    this.fallbackState = null;
+    try {
+      sessionStorage.removeItem(this.storageKey());
+    } catch {
+    }
+  }
+  resolveActiveState(nowMs) {
+    let state = this.read();
+    return !state || isExpired(state, nowMs) ? newSession(nowMs) : state;
+  }
+  read() {
+    try {
+      let serialized = sessionStorage.getItem(this.storageKey());
+      if (!serialized) return this.fallbackState;
+      let state = JSON.parse(serialized);
+      return isPersistedSession(state) ? (this.fallbackState = state, state) : (sessionStorage.removeItem(this.storageKey()), this.fallbackState);
+    } catch {
+      return this.fallbackState;
+    }
+  }
+  write(state) {
+    this.fallbackState = state;
+    try {
+      sessionStorage.setItem(this.storageKey(), JSON.stringify(state));
+    } catch {
+    }
+  }
+  storageKey() {
+    return `${ANALYTICS_SESSION_STORAGE_KEY_PREFIX}${encodeURIComponent(this.identity)}`;
+  }
+};
+function newSession(nowMs) {
+  return {
+    version: 2,
+    id: generateSessionId(),
+    startedAtMs: nowMs,
+    lastActivityAtMs: nowMs,
+    bootstrapped: false
+  };
+}
+function toContext(state) {
+  return {
+    id: state.id,
+    startedAt: new Date(state.startedAtMs).toISOString(),
+    requiresBootstrap: !state.bootstrapped
+  };
+}
+function toEventContext(state, occurredAtMicros) {
+  return {
+    ...toContext(state),
+    occurredAt: formatEpochMicros(occurredAtMicros)
+  };
+}
+function reserveOccurredAt(state, nowMs, eventCount) {
+  let wallClockMicros = Math.trunc(nowMs) * 1e3, occurredAtMicros = Math.max(
+    wallClockMicros,
+    (state.lastOccurredAtMicros ?? wallClockMicros - 1) + 1
+  );
+  return state.lastOccurredAtMicros = occurredAtMicros + eventCount - 1, occurredAtMicros;
+}
+function formatEpochMicros(epochMicros) {
+  let epochMillis = Math.floor(epochMicros / 1e3), microsWithinSecond = epochMicros % 1e6;
+  return `${new Date(epochMillis).toISOString().slice(0, -5)}.${String(microsWithinSecond).padStart(6, "0")}Z`;
+}
+function durationFor(activePage, nowMs) {
+  if (!(!activePage || nowMs < activePage.enteredAtMs))
+    return {
+      path: activePage.path,
+      timeOnPageSeconds: Math.floor((nowMs - activePage.enteredAtMs) / 1e3)
+    };
+}
+function isExpired(state, nowMs) {
+  return nowMs - state.lastActivityAtMs >= 18e5;
+}
+function isPersistedSession(value) {
+  if (!value || typeof value != "object") return false;
+  let state = value;
+  return state.version === 2 && typeof state.id == "string" && state.id.length > 0 && typeof state.startedAtMs == "number" && Number.isFinite(state.startedAtMs) && typeof state.lastActivityAtMs == "number" && Number.isFinite(state.lastActivityAtMs) && (state.lastOccurredAtMicros === void 0 || typeof state.lastOccurredAtMicros == "number" && Number.isSafeInteger(state.lastOccurredAtMicros)) && typeof state.bootstrapped == "boolean" && (!state.activePage || typeof state.activePage.path == "string" && typeof state.activePage.enteredAtMs == "number" && Number.isFinite(state.activePage.enteredAtMs));
+}
+function generateSessionId() {
+  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (character) => {
+    let random = Math.random() * 16 | 0;
+    return (character === "x" ? random : random & 3 | 8).toString(16);
+  });
+}
+
+// src/activity.ts
+var VISITOR_ID_STORAGE_KEY = "cimplify_visitor_id", ACTIVITY_RETRY_POLICY = {
+  maxRetries: 1,
+  jitterRatio: 0.2
+}, PAGE_VIEW_TRACKER_KEY = /* @__PURE__ */ Symbol.for("@cimplify/sdk.page-view-tracker-hub"), PAGE_VIEW_TRACKER_VERSION = 2;
+function trackerHost() {
+  return window;
+}
+function currentWindowTrackerHub() {
+  let candidate = trackerHost()[PAGE_VIEW_TRACKER_KEY];
+  return candidate?.version === (2) && candidate.registrations instanceof Map && typeof candidate.recordAll == "function" ? candidate : null;
+}
+function weakReference(target) {
+  let WeakReference = globalThis.WeakRef;
+  return WeakReference ? new WeakReference(target) : { deref: () => target };
+}
+function latestLiveOwner(registration) {
+  let latest = null;
+  for (let [token, reference] of registration.owners) {
+    let owner = reference.deref();
+    !owner || owner.released ? registration.owners.delete(token) : latest = owner;
+  }
+  return latest;
+}
+function recordRegistration(registration, path) {
+  if (path === registration.lastPath) return;
+  let owner = registration.activeOwner && !registration.activeOwner.released ? registration.activeOwner : latestLiveOwner(registration);
+  owner && (registration.activeOwner = owner, registration.lastPath = path, owner.recorder(path));
+}
+function createWindowTrackerHub() {
+  let originalPushState = window.history.pushState, originalReplaceState = window.history.replaceState, hub = {
+    version: (2),
+    registrations: /* @__PURE__ */ new Map(),
+    originalPushState,
+    originalReplaceState
+  };
+  return hub.recordAll = () => {
+    let path = window.location.pathname;
+    for (let 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, hub;
+}
+function pageViewTrackerIdentity(client) {
+  return JSON.stringify([client.getBaseUrl(), client.getPublicKey().trim()]);
+}
+function acquireWindowPageViewTracker(identity, recorder) {
+  let hub = currentWindowTrackerHub() ?? createWindowTrackerHub(), registration = hub.registrations.get(identity), isNewIdentity = !registration;
+  registration || (registration = { owners: /* @__PURE__ */ new Map(), activeOwner: null, lastPath: null }, hub.registrations.set(identity, registration));
+  let owner = {
+    token: Symbol(identity),
+    recorder,
+    released: false
+  };
+  registration.owners.set(owner.token, weakReference(owner)), registration.activeOwner = owner, isNewIdentity && recordRegistration(registration, window.location.pathname);
+  let released = false;
+  return () => {
+    released || (released = true, owner.released = true, registration.owners.delete(owner.token), registration.activeOwner === owner && (registration.activeOwner = latestLiveOwner(registration)), !registration.activeOwner && (hub.registrations.get(identity) === registration && hub.registrations.delete(identity), hub.registrations.size === 0 && (window.removeEventListener("popstate", hub.popstateListener), window.history.pushState === hub.patchedPushState && (window.history.pushState = hub.originalPushState), window.history.replaceState === hub.patchedReplaceState && (window.history.replaceState = hub.originalReplaceState), currentWindowTrackerHub() === hub && delete trackerHost()[PAGE_VIEW_TRACKER_KEY])));
+  };
+}
+var ActivityService = class {
+  constructor(client) {
+    this.client = client;
+    this.localGeneration = 0;
+    this.bootstrapRequest = null;
+    this.sessions = this.createSessionCoordinator();
+  }
+  /**
+   * Record session start (landing, referrer, UTM, device). Fire-and-forget,
+   * at most once per 30-minute-idle analytics session; called automatically
+   * by the track* methods.
+   */
+  startSession() {
+    if (typeof window > "u") return;
+    let session = this.sessions.beginEvent();
+    this.bootstrapSession(session, false, this.captureGeneration()).catch(() => {
+    });
+  }
+  /** Rebind an existing analytics session after the server authenticates a customer. */
+  refreshIdentity() {
+    if (typeof window > "u") return;
+    let session = this.sessions.current();
+    session && this.bootstrapSession(session, true, this.captureGeneration()).catch(() => {
+    });
+  }
+  /** A signed-out browser starts a fresh anonymous analytics session. */
+  resetSession() {
+    this.invalidatePendingActivity(), this.sessions.reset();
+  }
+  /** 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) {
+    let params = new URLSearchParams(window.location.search), utm = (key) => params.get(`utm_${key}`) || void 0, { visitorId, isNewVisitor } = resolveVisitor(), timezone;
+    try {
+      timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch {
+    }
+    return {
+      analytics_session_id: session.id,
+      started_at: session.startedAt,
+      landing_page: window.location.pathname,
+      landing_url: window.location.href,
+      referrer_url: document.referrer || void 0,
+      utm_source: utm("source"),
+      utm_medium: utm("medium"),
+      utm_campaign: utm("campaign"),
+      utm_term: utm("term"),
+      utm_content: utm("content"),
+      social_commerce_ref: params.get("social_commerce_ref") || void 0,
+      screen_width: window.screen?.width,
+      screen_height: window.screen?.height,
+      viewport_width: window.innerWidth,
+      viewport_height: window.innerHeight,
+      pixel_density: window.devicePixelRatio,
+      language: navigator.language,
+      timezone,
+      fingerprint: visitorId,
+      is_new_visitor: isNewVisitor
+    };
+  }
+  /** Route-level page view. Product/category interactions are tracked separately. */
+  trackPageView(options = {}) {
+    if (typeof window > "u") return;
+    let pagePath = options.pagePath ?? currentPath() ?? "", transition = this.sessions.beginPage(pagePath), events = [];
+    transition.previousPage && events.push({
+      type: "page_duration",
+      page_path: transition.previousPage.path,
+      time_on_page: transition.previousPage.timeOnPageSeconds
+    }), events.push({
+      type: "page_view",
+      page_path: pagePath,
+      page_title: options.pageTitle ?? currentTitle()
+    }), this.sendEvents(events, transition.session);
+  }
+  trackProductView(productId, options = {}) {
+    if (typeof window > "u") return;
+    let event = {
+      type: "product_view",
+      product_id: productId,
+      product_name: options.productName,
+      category_id: options.categoryId,
+      price: options.price,
+      page_path: options.pagePath ?? currentPath()
+    };
+    this.sendEvents([event]);
+  }
+  trackCategoryView(categoryId, options = {}) {
+    if (typeof window > "u") return;
+    let event = {
+      type: "category_view",
+      category_id: categoryId,
+      category_name: options.categoryName,
+      page_path: options.pagePath ?? currentPath()
+    };
+    this.sendEvents([event]);
+  }
+  async getState() {
+    return chunkOMTVH334_js.safe(this.client.get("/api/v1/activity/state"));
+  }
+  async getRecommendations(options) {
+    let params = new URLSearchParams();
+    options?.location_id && params.set("location_id", options.location_id), options?.limit && params.set("limit", String(options.limit));
+    let query = params.toString(), path = query ? `/api/v1/activity/recommendations?${query}` : "/api/v1/activity/recommendations";
+    return chunkOMTVH334_js.safe(this.client.get(path));
+  }
+  async dismissMessage(code) {
+    return chunkOMTVH334_js.safe(
+      this.client.post("/api/v1/activity/messages/dismiss", { code })
+    );
+  }
+  /** Records a page view now and on every route change; returns a stop fn. */
+  autoTrackPageViews() {
+    return typeof window > "u" ? () => {
+    } : acquireWindowPageViewTracker(pageViewTrackerIdentity(this.client), (path) => {
+      try {
+        this.trackPageView({ pagePath: path });
+      } catch {
+      }
+    });
+  }
+  sendEvents(events, session) {
+    typeof window > "u" || this.postEvents(events, session ?? this.sessions.beginEvent()).catch(() => {
+    });
+  }
+  hasStorefrontIdentity() {
+    return this.client.getPublicKey().trim().length > 0;
+  }
+  async postEvents(events, session) {
+    if (!this.hasStorefrontIdentity()) return;
+    let generation = this.captureGeneration();
+    await this.bootstrapSession(session, false, generation), this.isCurrentGeneration(generation) && 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, generation = this.captureGeneration()) {
+    if (!this.hasStorefrontIdentity() || !force && !session.requiresBootstrap) return Promise.resolve();
+    if (!force && this.bootstrapRequest?.sessionId === session.id && sameActivityGeneration(this.bootstrapRequest.generation, generation))
+      return this.bootstrapRequest.promise;
+    let promise = this.client.post("/api/v1/activity/session", this.buildSessionPayload(session), {
+      retryPolicy: ACTIVITY_RETRY_POLICY
+    }).then(() => {
+      this.isCurrentGeneration(generation) && this.sessions.markBootstrapped(session.id);
+    }).finally(() => {
+      this.bootstrapRequest?.promise === promise && (this.bootstrapRequest = null);
+    });
+    return this.bootstrapRequest = { sessionId: session.id, generation, promise }, 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 < "u")
+    return window.location.pathname;
+}
+function currentTitle() {
+  if (typeof document < "u" && document.title)
+    return document.title;
+}
+function resolveVisitor() {
+  try {
+    let existing = localStorage.getItem(VISITOR_ID_STORAGE_KEY);
+    if (existing)
+      return { visitorId: existing, isNewVisitor: !1 };
+    let visitorId = typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : `v_${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+    return localStorage.setItem(VISITOR_ID_STORAGE_KEY, visitorId), { visitorId, isNewVisitor: !0 };
+  } catch {
+    return {};
+  }
+}
+
+// src/subscriptions.ts
+var SubscriptionService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    return chunkOMTVH334_js.safe(this.client.get("/api/v1/subscriptions"));
+  }
+  async get(id) {
+    let encodedId = encodeURIComponent(id);
+    return chunkOMTVH334_js.safe(this.client.get(`/api/v1/subscriptions/${encodedId}`));
+  }
+  async cancel(id, reason, opts) {
+    let encodedId = encodeURIComponent(id), idempotencyKey = opts?.idempotencyKey ?? chunkOMTVH334_js.generateIdempotencyKey();
+    return chunkOMTVH334_js.safe(
+      this.client.post(
+        `/api/v1/subscriptions/${encodedId}/cancel`,
+        { reason },
+        { idempotencyKey }
+      )
+    );
+  }
+  async pause(id) {
+    let encodedId = encodeURIComponent(id);
+    return chunkOMTVH334_js.safe(
+      this.client.post(`/api/v1/subscriptions/${encodedId}/pause`)
+    );
+  }
+  async resume(id) {
+    let encodedId = encodeURIComponent(id);
+    return chunkOMTVH334_js.safe(
+      this.client.post(`/api/v1/subscriptions/${encodedId}/resume`)
+    );
+  }
+  async skipNextRenewal(id, opts) {
+    let encodedId = encodeURIComponent(id), idempotencyKey = opts?.idempotencyKey ?? chunkOMTVH334_js.generateIdempotencyKey();
+    return chunkOMTVH334_js.safe(
+      this.client.post(
+        `/api/v1/subscriptions/${encodedId}/skip`,
+        void 0,
+        { idempotencyKey }
+      )
+    );
+  }
+};
+var CONTENT_SHA256_HEADER = "x-amz-checksum-sha256", HASH_CHUNK_BYTES = 4 * 1024 * 1024, HEX_RADIX = 16, HEX_BYTE_WIDTH = 2;
+async function contentSha256(blob) {
+  let hasher = sha2_js.sha256.create();
+  for (let offset = 0; offset < blob.size; offset += HASH_CHUNK_BYTES)
+    hasher.update(new Uint8Array(await blob.slice(offset, offset + HASH_CHUNK_BYTES).arrayBuffer()));
+  let digest = hasher.digest(), hex = "", binary = "";
+  for (let byte of digest)
+    hex += byte.toString((16)).padStart((2), "0"), binary += String.fromCharCode(byte);
+  return { hex, base64: btoa(binary) };
+}
+var UploadService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * With `opts.digest` the PUT to `upload_url` must send `digest.base64` as
+   * `CONTENT_SHA256_HEADER`; without it the server hashes the stored bytes.
+   */
+  async init(filename, contentType2, sizeBytes, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? chunkOMTVH334_js.generateIdempotencyKey();
+    return chunkOMTVH334_js.safe(
+      this.client.post(
+        "/api/v1/uploads/init",
+        {
+          filename,
+          content_type: contentType2,
+          size_bytes: sizeBytes,
+          content_sha256: opts?.digest?.hex
+        },
+        { idempotencyKey }
+      )
+    );
+  }
+  async confirm(uploadId) {
+    return chunkOMTVH334_js.safe(
+      this.client.post("/api/v1/uploads/confirm", {
+        upload_id: uploadId
+      })
+    );
+  }
+  async upload(file) {
+    let digest = await contentSha256(file), initResult = await this.init(file.name, file.type, file.size, { digest });
+    if (!initResult.ok) return initResult;
+    let { upload_id, upload_url } = initResult.value;
+    try {
+      let uploadResponse = await fetch(upload_url, {
+        method: "PUT",
+        body: file,
+        headers: { "Content-Type": file.type, [CONTENT_SHA256_HEADER]: digest.base64 }
+      });
+      if (!uploadResponse.ok)
+        return {
+          ok: !1,
+          error: new chunkUCR5HRYM_js.CimplifyError(
+            "UPLOAD_FAILED",
+            `Upload failed with status ${uploadResponse.status}`,
+            !0
+          )
+        };
+    } catch (error) {
+      return {
+        ok: false,
+        error: new chunkUCR5HRYM_js.CimplifyError(
+          "UPLOAD_FAILED",
+          error instanceof Error ? error.message : "Upload failed",
+          true
+        )
+      };
+    }
+    return this.confirm(upload_id);
+  }
+};
+
+// src/places.ts
+var PlacesService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** `country` (ISO alpha-2) biases results; absent, the store's own country. */
+  async autocomplete(input, sessionToken, country) {
+    return chunkOMTVH334_js.safe(
+      this.client.post("/api/v1/places/autocomplete", {
+        input,
+        sessionToken,
+        ...country ? { country } : {}
+      })
+    );
+  }
+  /**
+   * `country` (ISO alpha-2) is the country the place must lie in; pass the one
+   * the autocomplete used. Absent, the store's own country.
+   */
+  async details(placeId, sessionToken, country) {
+    return chunkOMTVH334_js.safe(
+      this.client.post("/api/v1/places/details", {
+        place_id: placeId,
+        sessionToken,
+        ...country ? { country } : {}
+      })
+    );
+  }
+};
+
+// src/delivery.ts
+var DeliveryService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getFee(dropoffLat, dropoffLng, country) {
+    let params = new URLSearchParams();
+    return params.set("dropoff_lat", String(dropoffLat)), params.set("dropoff_lng", String(dropoffLng)), country && params.set("country", country), chunkOMTVH334_js.safe(this.client.get(`/api/v1/delivery/fee?${params.toString()}`));
+  }
+  async getOptions(queryOrLatitude, longitude, legacyOptions) {
+    let query = typeof queryOrLatitude == "number" ? {
+      ...legacyOptions,
+      dropoffLat: queryOrLatitude,
+      dropoffLng: longitude
+    } : queryOrLatitude ?? {}, params = new URLSearchParams();
+    return query.dropoffLat != null && params.set("dropoff_lat", String(query.dropoffLat)), query.dropoffLng != null && params.set("dropoff_lng", String(query.dropoffLng)), query.country && params.set("country", query.country), query.currency && params.set("currency", query.currency), query.orderValue != null && params.set("order_value", String(query.orderValue)), chunkOMTVH334_js.safe(
+      this.client.get(`/api/v1/delivery/options?${params.toString()}`)
+    );
+  }
+};
+
+// src/chat-wire.ts
+function senderType(message) {
+  return message.sender_side === "account" ? "customer" : message.sender_side === "system" ? "system" : message.authorship === "ai" ? "bot" : "agent";
+}
+function contentType(message) {
+  if (message.content_type === "rich")
+    return message.structured_content?.kind === "reaction" ? "reaction" : "interactive";
+  if (message.content_type === "media") {
+    let mime = message.media[0]?.mime_type ?? "";
+    return mime.startsWith("image/") ? "image" : mime.startsWith("video/") ? "video" : mime.startsWith("audio/") ? "audio" : "document";
+  }
+  return "text";
+}
+function unresolvedReply(id) {
+  return { id, sender_type: "system", preview: "Earlier message" };
+}
+function chatMessagesFromWire(messages) {
+  let converted = messages.map((message) => ({
+    id: message.id,
+    sequence: message.sequence,
+    sender_type: senderType(message),
+    content: message.content,
+    content_type: contentType(message),
+    attachments: Array.isArray(message.media) ? message.media : [],
+    metadata: message.structured_content ?? {},
+    reply_to: message.reply_to_message_id ? unresolvedReply(message.reply_to_message_id) : void 0,
+    edited_at: message.edited_at,
+    deleted_at: message.deleted_at,
+    created_at: message.created_at
+  })), byId = new Map(converted.map((message) => [message.id, message]));
+  return converted.map((message) => {
+    let targetId = message.reply_to?.id, target = targetId ? byId.get(targetId) : void 0;
+    return !targetId || !target ? message : {
+      ...message,
+      reply_to: {
+        id: targetId,
+        sender_type: target.sender_type,
+        preview: chunkWOF3AD3J_js.messagePreview(target.content)
+      }
+    };
+  });
+}
+function chatMessageFromWire(message) {
+  return chatMessagesFromWire([message])[0];
+}
+function chatRealtimeUpdateFromWire(envelope) {
+  if (envelope.type === "message_created" && envelope.data)
+    return {
+      kind: "message",
+      message: chatMessageFromWire(envelope.data)
+    };
+  if (envelope.type === "message_updated" && envelope.data)
+    return {
+      kind: "message_updated",
+      message: chatMessageFromWire(envelope.data)
+    };
+  if (envelope.type === "read" && envelope.data) {
+    let read = envelope.data;
+    return read.reader_side === "business" && typeof read.occurred_at == "string" ? { kind: "business_read", occurredAt: read.occurred_at } : { kind: "none" };
+  }
+  if (envelope.type === "history_imported")
+    return { kind: "reload" };
+  if (envelope.type === "ai_mode_changed" && envelope.data) {
+    let mode = envelope.data.mode;
+    return mode === "auto" || mode === "assist" || mode === "off" ? { kind: "ai_mode", mode } : { kind: "none" };
+  }
+  return envelope.type === "handoff_requested" ? { kind: "handoff" } : envelope.type === "resync" ? { kind: "resync", latestSequence: envelope.latest_sequence } : { kind: "none" };
+}
+
+// src/support.ts
+var SupportService = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Retry verified external-history discovery for the current storefront.
+   * Launch scope is intentionally WhatsApp-only because it is the registered
+   * bidirectional transport. Results are per envelope and omit provider ids,
+   * contact values, account ids, and message bodies.
+   */
+  async claimExternalChats() {
+    return this.client.getAccessToken() ? chunkOMTVH334_js.safe(
+      (async () => {
+        let businessId = await this.client.resolveBusinessId();
+        return this.client.post("/v1/me/chats/external-claims", {
+          business_id: businessId
+        });
+      })()
+    ) : chunkOMTVH334_js.err(new chunkUCR5HRYM_js.CimplifyError("not_authenticated", "No access token to claim with"));
+  }
+  /**
+   * Peek at the conversation without creating one: resolves the existing
+   * thread (or null) so a page load can hydrate history without littering
+   * the inbox with empty threads.
+   */
+  async peekConversation() {
+    let result = await chunkOMTVH334_js.safe(
+      this.client.get("/api/v1/support/conversation")
+    );
+    return result.ok ? result.value.conversation ? chunkOMTVH334_js.ok({
+      conversation: result.value.conversation,
+      messages: chatMessagesFromWire(result.value.messages)
+    }) : chunkOMTVH334_js.ok(null) : result;
+  }
+  /** Open (or resume) the customer's widget conversation. */
+  async openConversation(opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? chunkOMTVH334_js.generateIdempotencyKey(), result = await chunkOMTVH334_js.safe(
+      this.client.post("/api/v1/support/conversation", void 0, {
+        idempotencyKey
+      })
+    );
+    return result.ok ? chunkOMTVH334_js.ok({
+      conversation: result.value.conversation,
+      messages: chatMessagesFromWire(result.value.messages)
+    }) : result;
+  }
+  /**
+   * Send a message in the active conversation.
+   *
+   * The idempotency key doubles as the message `client_id`: the backend
+   * dedupes on it, so client retries of the same send never insert twice.
+   * `replyToMessageId` quotes another message by its `ChatMessage.id`; the
+   * server resolves it thread-scoped and echoes the quote as `reply_to`.
+   */
+  async sendMessage(content, opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? chunkOMTVH334_js.generateIdempotencyKey(), result = await chunkOMTVH334_js.safe(
+      this.client.post(
+        "/api/v1/support/conversation/messages",
+        {
+          content,
+          client_id: idempotencyKey,
+          reply_to_message_id: opts?.replyToMessageId,
+          upload_ids: opts?.attachments?.map((a) => a.upload_id)
+        },
+        { idempotencyKey }
+      )
+    );
+    return result.ok ? chunkOMTVH334_js.ok(chatMessageFromWire(result.value.message)) : result;
+  }
+  /**
+   * Poll for messages. `after` pages forward (live updates); `before` pages
+   * backward for scrollback into older history.
+   */
+  async getMessages(options = {}) {
+    let params = new URLSearchParams();
+    options.afterSequence !== void 0 && params.set("after_sequence", String(options.afterSequence)), options.beforeSequence !== void 0 && params.set("before_sequence", String(options.beforeSequence)), options.limit && params.set("limit", String(options.limit));
+    let query = params.toString(), path = query ? `/api/v1/support/conversation/messages?${query}` : "/api/v1/support/conversation/messages", result = await chunkOMTVH334_js.safe(this.client.get(path));
+    return result.ok ? chunkOMTVH334_js.ok(chatMessagesFromWire(result.value)) : result;
+  }
+  /** React to a message in the active conversation by its `ChatMessage.id`. */
+  async reactToMessage(messageId, emoji) {
+    let clientId = chunkOMTVH334_js.generateIdempotencyKey(), result = await chunkOMTVH334_js.safe(
+      this.client.post(
+        `/api/v1/support/conversation/messages/${messageId}/reactions`,
+        { emoji, client_id: clientId },
+        { idempotencyKey: clientId }
+      )
+    );
+    return result.ok ? chunkOMTVH334_js.ok(chatMessageFromWire(result.value.message)) : result;
+  }
+  /** Ask for a person: flags the thread for the merchant's inbox. */
+  async requestHuman(opts) {
+    let idempotencyKey = opts?.idempotencyKey ?? chunkOMTVH334_js.generateIdempotencyKey();
+    return chunkOMTVH334_js.safe(
+      this.client.post(
+        "/api/v1/support/conversation/handoff",
+        void 0,
+        { idempotencyKey }
+      )
+    );
+  }
+};
+
+// src/session.ts
+var CLAIM_TIMEOUT_MS = 15e3, CLAIM_PATH = "/api/v1/auth/session/claim", SessionService = class {
+  constructor(client) {
+    this.client = client;
+    this.claimInFlight = null;
+    this.claimInFlightToken = null;
+    this.lastClaimedAccessToken = null;
+    this.claimedName = null;
+    this.client.events.on(chunkOMTVH334_js.SESSION_CLEARED, () => {
+      this.lastClaimedAccessToken = null, this.claimedName = null;
+    }), this.client.events.on(chunkOMTVH334_js.SESSION_CLAIMED, (event) => {
+      event.customerName && (this.claimedName = event.customerName);
+    });
+  }
+  /** The verified customer this session is bound to, null while anonymous. */
+  get claimedCustomerName() {
+    return this.claimedName;
+  }
+  /** Adopt a session another holder already bound, for this bearer or, with
+   * `null`, for a bearer this client never holds (the checkout element). */
+  adopt(accessToken, session) {
+    this.lastClaimedAccessToken = accessToken, this.claimedName = session.customerName || null, this.client.adoptSessionToken(session.sessionToken), this.client.publishSessionClaimed(this.claimedName), this.client.events.emit(chunkOMTVH334_js.SESSION_CLAIMED, session);
+  }
+  /**
+   * Bind the anonymous session to the verified Link identity in one server
+   * transaction: verify the bearer, rotate the session token (adopted here),
+   * fold the guest cart under the customer and re-price it. A repeat for the
+   * same account and session returns the same session.
+   *
+   * Idempotent and single-flight: concurrent calls share one request, and a
+   * token already claimed by this instance short-circuits without a network
+   * round trip. A session already bound to another Link account is rejected
+   * rather than transferring that account's cart. Emits `session:claimed` on
+   * the client's event channel.
+   */
+  async claim() {
+    let accessToken = this.client.getAccessToken();
+    if (!accessToken)
+      return chunkOMTVH334_js.err(new chunkUCR5HRYM_js.CimplifyError("not_authenticated", "No access token to claim with"));
+    if (this.claimInFlight)
+      return this.claimInFlightToken === accessToken ? this.claimInFlight : (await this.claimInFlight, this.claim());
+    if (this.lastClaimedAccessToken === accessToken)
+      return chunkOMTVH334_js.err(new chunkUCR5HRYM_js.CimplifyError("already_claimed", "Session already claimed for this token"));
+    let epoch = this.client.getSessionEpoch();
+    this.claimInFlightToken = accessToken, this.claimInFlight = (async () => {
+      let result = await chunkOMTVH334_js.safe(
+        this.client.post(
+          CLAIM_PATH,
+          { access_token: accessToken },
+          { timeoutMs: (15e3) }
+        )
+      );
+      if (result.ok) {
+        if (this.client.getSessionEpoch() !== epoch)
+          return chunkOMTVH334_js.err(
+            new chunkUCR5HRYM_js.CimplifyError("session_cleared", "Session was cleared during the claim")
+          );
+        this.adopt(accessToken, {
+          sessionToken: result.value.session_token,
+          customerName: result.value.customer.name,
+          customer: result.value.customer,
+          cart: result.value.cart
+        });
+      }
+      return result;
+    })();
+    try {
+      return await this.claimInFlight;
+    } finally {
+      this.claimInFlight = null, this.claimInFlightToken = null;
+    }
+  }
+};
+
+// src/internal/cross-tab-session.ts
+var CROSS_TAB_SESSION_HUB_KEY = /* @__PURE__ */ Symbol.for("@cimplify/sdk.cross-tab-session-hub"), SESSION_SYNC_STORAGE_KEY = "cimplify_session_sync", MAX_RECENT_ENVELOPES = 64;
+function hubHost() {
+  return window;
+}
+function currentHub() {
+  let 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) {
+  let WeakReference = globalThis.WeakRef;
+  return WeakReference ? new WeakReference(target) : { deref: () => target };
+}
+function pruneSubscribers(hub) {
+  for (let [token, reference] of hub.subscribers)
+    reference.deref() || hub.subscribers.delete(token);
+}
+function parseSessionSyncPayload(serialized) {
+  if (!serialized) return null;
+  try {
+    let 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 sessionSyncEnvelopeKey(payload) {
+  let name = payload.name === void 0 ? ["missing"] : ["present", payload.name];
+  return JSON.stringify([payload.type, payload.token, name, payload.at]);
+}
+function rememberEnvelope(hub, envelope) {
+  if (hub.recentEnvelopes.has(envelope)) return false;
+  if (hub.recentEnvelopes.add(envelope), hub.recentEnvelopes.size > (64)) {
+    let oldest = hub.recentEnvelopes.values().next().value;
+    oldest && hub.recentEnvelopes.delete(oldest);
+  }
+  return true;
+}
+function createHub() {
+  let hub = {
+    subscribers: /* @__PURE__ */ new Map(),
+    recentEnvelopes: /* @__PURE__ */ new Set()
+  };
+  return hub.dispatch = (payload) => {
+    if (rememberEnvelope(hub, sessionSyncEnvelopeKey(payload)))
+      for (let [token, reference] of hub.subscribers) {
+        let subscriber = reference.deref();
+        if (!subscriber) {
+          hub.subscribers.delete(token);
+          continue;
+        }
+        try {
+          subscriber.notify(payload);
+        } catch {
+        }
+      }
+  }, hub.storageListener = (event) => {
+    let storageEvent = event;
+    if (storageEvent.key !== SESSION_SYNC_STORAGE_KEY) return;
+    let payload = parseSessionSyncPayload(storageEvent.newValue);
+    payload && hub.dispatch(payload);
+  }, window.addEventListener("storage", hub.storageListener), hubHost()[CROSS_TAB_SESSION_HUB_KEY] = hub, hub;
+}
+function publishLocalSessionSync(payload) {
+  typeof window > "u" || typeof window.addEventListener != "function" || (currentHub() ?? createHub()).dispatch(payload);
+}
+function subscribeCrossTabSession(notify) {
+  if (typeof window > "u" || typeof window.addEventListener != "function")
+    return () => {
+    };
+  let hub = currentHub() ?? createHub();
+  pruneSubscribers(hub);
+  let token = /* @__PURE__ */ Symbol("cross-tab-session-subscriber"), subscriber = { notify };
+  hub.subscribers.set(token, subscriberReference(subscriber));
+  let unsubscribed = false;
+  return () => {
+    unsubscribed || (unsubscribed = true, subscriber.notify = () => {
+    }, hub.subscribers.delete(token), pruneSubscribers(hub), hub.subscribers.size === 0 && (window.removeEventListener("storage", hub.storageListener), currentHub() === hub && delete hubHost()[CROSS_TAB_SESSION_HUB_KEY]));
+  };
+}
+
+// src/client.ts
+var SESSION_TOKEN_STORAGE_KEY = "cimplify_session_token", ORDER_TOKEN_PREFIX = "cimplify_ot_", SESSION_TOKEN_HEADER = "x-session-token", LOCATION_ID_QUERY_PARAMETER = "location_id", ORDER_TOKEN_TTL_MS = 1440 * 60 * 1e3, DEFAULT_TIMEOUT_MS = 5e3, HTTP_SERVER_ERROR_STATUS = 500, HTTP_TOO_MANY_REQUESTS = 429, HTTP_SERVICE_UNAVAILABLE = 503, RETRY_AFTER_HEADER = "Retry-After", DEFAULT_MAX_RETRIES = 3, DEFAULT_RETRY_DELAY_MS = 1e3, MAX_RETRY_AFTER_MS = 3e4;
+function sleep(ms, signal) {
+  return signal?.aborted ? Promise.reject(new chunkUCR5HRYM_js.CimplifyError(chunkUCR5HRYM_js.ErrorCode.CANCELLED, "Request was cancelled.", true)) : new Promise((resolve, reject) => {
+    let timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort), resolve();
+    }, ms), onAbort = () => {
+      clearTimeout(timer), reject(new chunkUCR5HRYM_js.CimplifyError(chunkUCR5HRYM_js.ErrorCode.CANCELLED, "Request was cancelled.", true));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var MS_PER_SECOND = 1e3;
+function retryAfterDelayMs(value) {
+  if (!value) return null;
+  let seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0)
+    return seconds * (1e3);
+  let retryAt = Date.parse(value);
+  return Number.isFinite(retryAt) ? Math.max(0, retryAt - Date.now()) : null;
+}
+function parseRetryAfterMs(value) {
+  let delayMs = retryAfterDelayMs(value);
+  return delayMs === null ? null : Math.min(delayMs, (3e4));
+}
+function withPositiveJitter(delayMs, jitterRatio = 0) {
+  let boundedRatio = Math.min(Math.max(jitterRatio, 0), 1);
+  return boundedRatio === 0 || delayMs === 0 ? delayMs : Math.round(delayMs + delayMs * boundedRatio * Math.random());
+}
+function nextInit(cacheOptions) {
+  if (!cacheOptions) return {};
+  let next = {};
+  return cacheOptions.revalidate !== void 0 && (next.revalidate = cacheOptions.revalidate), cacheOptions.tags && cacheOptions.tags.length > 0 && (next.tags = [...cacheOptions.tags]), next.revalidate === void 0 && !next.tags ? {} : { next };
+}
+function mergeOptionHeaders(base, opts) {
+  if (!opts) return base;
+  let merged = { ...base };
+  if (opts.headers)
+    for (let [k, v] of Object.entries(opts.headers))
+      merged[k] = v;
+  return opts.idempotencyKey && (merged["Idempotency-Key"] = opts.idempotencyKey), merged;
+}
+function generateSessionToken() {
+  return typeof crypto < "u" && crypto.randomUUID ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    let r = Math.random() * 16 | 0;
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+function isRetryable(error) {
+  return error instanceof TypeError && error.message.includes("fetch") || error instanceof DOMException && error.name === "AbortError" ? true : error instanceof chunkUCR5HRYM_js.CimplifyError ? error.retryable : false;
+}
+function toNetworkError(error, isTestMode) {
+  return error instanceof DOMException && error.name === "AbortError" ? chunkUCR5HRYM_js.enrichError(
+    new chunkUCR5HRYM_js.CimplifyError(
+      chunkUCR5HRYM_js.ErrorCode.TIMEOUT,
+      "Request timed out. Please check your connection and try again.",
+      true
+    ),
+    { isTestMode }
+  ) : error instanceof TypeError && error.message.includes("fetch") ? chunkUCR5HRYM_js.enrichError(
+    new chunkUCR5HRYM_js.CimplifyError(
+      chunkUCR5HRYM_js.ErrorCode.NETWORK_ERROR,
+      "Network error. Please check your internet connection.",
+      true
+    ),
+    { isTestMode }
+  ) : error instanceof chunkUCR5HRYM_js.CimplifyError ? chunkUCR5HRYM_js.enrichError(error, { isTestMode }) : chunkUCR5HRYM_js.enrichError(
+    new chunkUCR5HRYM_js.CimplifyError(
+      chunkUCR5HRYM_js.ErrorCode.UNKNOWN_ERROR,
+      error instanceof Error ? error.message : "An unknown error occurred",
+      false
+    ),
+    { isTestMode }
+  );
+}
+function deriveUrls() {
+  let hostname = typeof window < "u" ? window.location.hostname : "";
+  if (hostname === "localhost" || hostname === "127.0.0.1") {
+    let protocol = window.location.protocol;
+    return {
+      baseUrl: `${protocol}//${hostname}:8082`,
+      linkApiUrl: `${protocol}//${hostname}:8080`
+    };
+  }
+  return {
+    baseUrl: "https://storefronts.cimplify.io",
+    linkApiUrl: "https://api.cimplify.io"
+  };
+}
+function normalizeUrl(url) {
+  let trimmed = url.trim();
+  return trimmed && trimmed.replace(/\/+$/, "");
+}
+function getEnvPublicKey() {
+  try {
+    return globalThis.process?.env.NEXT_PUBLIC_CIMPLIFY_PUBLIC_KEY || void 0;
+  } catch {
+    return;
+  }
+}
+var CimplifyClient = class {
+  constructor(config = {}) {
+    this.accessToken = null;
+    this.sessionToken = null;
+    this.sessionEpoch = 0;
+    this.context = {};
+    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
+     * activity, and dead-letter notifications to consumer code (toasts,
+     * Sentry, analytics, etc.). The SDK emits but never auto-consumes — the
+     * consumer decides how to react.
+     */
+    this.events = chunkOMTVH334_js.createClientEvents();
+    this.stopPageViewTracking = null;
+    this.publicKey = config.publicKey || getEnvPublicKey() || "";
+    let urls = deriveUrls();
+    this.baseUrl = config.baseUrl ? normalizeUrl(config.baseUrl) : urls.baseUrl, this.linkApiUrl = config.linkApiUrl ? normalizeUrl(config.linkApiUrl) : urls.linkApiUrl, this.credentials = config.credentials || "include", this.timeout = config.timeout ?? (5e3), this.maxRetries = config.maxRetries ?? (3), this.retryDelay = config.retryDelay ?? (1e3), this.hooks = config.hooks ?? {}, this.authorizationAdapters = config.authorizationAdapterRegistry ?? chunkOMTVH334_js.createDefaultPaymentAuthorizationAdapterRegistry(), this.fetchImpl = (config.fetch ?? globalThis.fetch).bind(globalThis), this.sessionToken = this.loadSessionToken() ?? this.mintSessionToken();
+    let persistedSessionSync = this.loadSessionSyncPayload();
+    persistedSessionSync && this.observeSessionSync(persistedSessionSync), this.stopCrossTabSessionWatch = subscribeCrossTabSession((payload) => {
+      this.applyCrossTabSession(payload);
+    }), !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().'
+    ), config.trackPageViews !== false && (this.stopPageViewTracking = this.activity.autoTrackPageViews());
+  }
+  buildUrl(base, path) {
+    let url = `${base}${path}`, locationId = this.context.location_id;
+    if (!locationId) return url;
+    let fragmentIndex = url.indexOf("#"), urlWithoutFragment = fragmentIndex === -1 ? url : url.slice(0, fragmentIndex), fragment = fragmentIndex === -1 ? "" : url.slice(fragmentIndex), queryIndex = urlWithoutFragment.indexOf("?"), query = queryIndex === -1 ? "" : urlWithoutFragment.slice(queryIndex + 1);
+    return new URLSearchParams(query).has(LOCATION_ID_QUERY_PARAMETER) ? url : `${urlWithoutFragment}${queryIndex === -1 ? "?" : "&"}${LOCATION_ID_QUERY_PARAMETER}=${encodeURIComponent(locationId)}${fragment}`;
+  }
+  stopTrackingPageViews() {
+    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;
+  }
+  getPublicKey() {
+    return this.publicKey;
+  }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  getLinkApiUrl() {
+    return this.linkApiUrl;
+  }
+  getCredentialsMode() {
+    return this.credentials;
+  }
+  isTestMode() {
+    return this.publicKey.trim().startsWith("cpk_test_");
+  }
+  setAccessToken(token) {
+    let previous = this.accessToken;
+    this.accessToken = token, previous !== token && this.sessionEpoch++, this.hooks.onSessionChange?.({
+      previousToken: previous,
+      newToken: token,
+      source: SESSION_CHANGE_SOURCE.MANUAL
+    }), this.events.emit(chunkOMTVH334_js.AUTH_TOKEN_CHANGED, { token });
+  }
+  /**
+   * Zero-UI claim: a freshly verified customer identity (OTP verify, silent
+   * refresh restore) binds the anonymous session so the conversation, cart
+   * and orders survive a cleared browser. Best-effort by design — a failed
+   * claim leaves the session anonymous, exactly as it was. Called by the
+   * merchant auth flows, never by the raw token setter. Global Link clients
+   * have no storefront tenant and therefore activate without this step.
+   */
+  autoClaimSession() {
+    typeof window > "u" || !this.sessionToken || !this.accessToken || this.session.claim();
+  }
+  /**
+   * Adopt a server-rotated session token (claim flow). The old token stays
+   * in flight-safe use until the next request; the storage swap makes the
+   * rotation durable across reloads.
+   */
+  adoptSessionToken(token) {
+    !token || token === this.sessionToken || (this.sessionToken = token, this.sessionEpoch++, this.saveSessionToken(token));
+  }
+  clearSession() {
+    let previous = this.accessToken;
+    this.accessToken = null, this._activity?.resetSession(), this.sessionToken = null, this.sessionEpoch++;
+    try {
+      this.safeStorage()?.removeItem(SESSION_TOKEN_STORAGE_KEY);
+    } catch {
+    }
+    this.sessionToken = this.mintSessionToken(), this.sessionToken && this.broadcastSessionSync({ type: "cleared", token: this.sessionToken }), this.hooks.onSessionChange?.({
+      previousToken: previous,
+      newToken: null,
+      source: SESSION_CHANGE_SOURCE.CLEAR
+    }), this.events.emit(chunkOMTVH334_js.AUTH_TOKEN_CHANGED, { token: null }), this.events.emit(chunkOMTVH334_js.SESSION_CLEARED, {});
+  }
+  getSessionEpoch() {
+    return this.sessionEpoch;
+  }
+  /** Monotonic fence for async work scoped to the current storefront tenant. */
+  getPublicKeyEpoch() {
+    return this.publicKeyEpoch;
+  }
+  getSessionToken() {
+    return this.sessionToken;
+  }
+  /** Whether the current transport session is known to have been claimed for
+   * a Link identity, even when its in-memory bearer is absent after reload or
+   * a failed refresh. The sync marker is written only after canonical claim
+   * rotation and is replaced with `cleared` when a fresh session is minted. */
+  hasClaimedSessionAuthority() {
+    if (!this.sessionToken) return false;
+    try {
+      let payload = parseSessionSyncPayload(
+        this.safeStorage()?.getItem(SESSION_SYNC_STORAGE_KEY) ?? null
+      );
+      return payload ? payload.type === "claimed" && payload.token === this.sessionToken : !1;
+    } catch {
+      return false;
+    }
+  }
+  publishSessionClaimed(customerName) {
+    this.sessionToken && this.broadcastSessionSync({
+      type: "claimed",
+      token: this.sessionToken,
+      name: customerName
+    });
+  }
+  broadcastSessionSync(payload) {
+    let envelope = {
+      ...payload,
+      at: this.nextSessionSyncTimestamp()
+    };
+    try {
+      this.safeStorage()?.setItem(SESSION_SYNC_STORAGE_KEY, JSON.stringify(envelope));
+    } catch {
+    }
+    publishLocalSessionSync(envelope);
+  }
+  applyCrossTabSession(payload) {
+    this.observeSessionSync(payload) && payload.token !== this.sessionToken && (payload.type === "claimed" ? (this.sessionToken = payload.token, this.sessionEpoch++, this.events.emit(chunkOMTVH334_js.SESSION_CLAIMED, {
+      sessionToken: payload.token,
+      customerName: payload.name ?? "",
+      customer: null,
+      cart: null
+    })) : (this.accessToken = null, this._activity?.resetSession(), this.sessionToken = payload.token, this.sessionEpoch++, this.events.emit(chunkOMTVH334_js.AUTH_TOKEN_CHANGED, { token: null }), this.events.emit(chunkOMTVH334_js.SESSION_CLEARED, {})));
+  }
+  observeSessionSync(payload) {
+    if (payload.at < this.latestSessionSyncAt) return false;
+    let envelope = sessionSyncEnvelopeKey(payload);
+    return payload.at === this.latestSessionSyncAt && this.latestSessionSyncOrderKey !== null && envelope <= this.latestSessionSyncOrderKey ? false : (this.latestSessionSyncAt = payload.at, this.latestSessionSyncOrderKey = envelope, true);
+  }
+  nextSessionSyncTimestamp() {
+    let now = Date.now();
+    return Number.isFinite(this.latestSessionSyncAt) ? Math.max(now, this.latestSessionSyncAt + 1) : now;
+  }
+  setOrderToken(orderId, token) {
+    try {
+      let entry = JSON.stringify({ token, storedAt: Date.now() });
+      this.safeStorage()?.setItem(`${ORDER_TOKEN_PREFIX}${orderId}`, entry);
+    } catch {
+    }
+  }
+  getOrderToken(orderId) {
+    try {
+      let storage = this.safeStorage();
+      if (!storage) return null;
+      let raw = storage.getItem(`${ORDER_TOKEN_PREFIX}${orderId}`);
+      if (!raw) return null;
+      let entry = JSON.parse(raw);
+      return Date.now() - entry.storedAt > ORDER_TOKEN_TTL_MS ? (storage.removeItem(`${ORDER_TOKEN_PREFIX}${orderId}`), null) : entry.token;
+    } catch {
+      return null;
+    }
+  }
+  clearOrderTokens() {
+    try {
+      let storage = this.safeStorage();
+      if (!storage) return;
+      let keysToRemove = [];
+      for (let i = 0; i < storage.length; i++) {
+        let key = storage.key(i);
+        key?.startsWith(ORDER_TOKEN_PREFIX) && keysToRemove.push(key);
+      }
+      keysToRemove.forEach((k) => storage.removeItem(k));
+    } catch {
+    }
+  }
+  setLocationId(locationId) {
+    locationId ? this.context.location_id = locationId : delete this.context.location_id;
+  }
+  getLocationId() {
+    return this.context.location_id ?? null;
+  }
+  setBusinessId(businessId) {
+    let normalized = businessId.trim();
+    normalized && (this.businessId = normalized);
+  }
+  // Set the storefront public key after construction. Needed by hosts that
+  // create the client before they know the key (e.g. the Link element, which
+  // receives it in its INIT message) — without it, storefront calls carry no
+  // X-API-Key and the business can't be resolved.
+  setPublicKey(publicKey) {
+    let normalized = publicKey.trim();
+    if (normalized === this.publicKey) return;
+    let restartPageViewTracking = this.stopPageViewTracking !== null;
+    restartPageViewTracking && this.stopTrackingPageViews(), this.publicKey = normalized, this.publicKeyEpoch += 1, this.businessId = null, this.businessIdResolvePromise = null, this.inflightRequests.clear(), this._activity?.resetForStorefrontIdentityChange(), delete this.context.location_id, this.accessToken !== null && this.setAccessToken(null), this.events.emit(chunkOMTVH334_js.SESSION_CLEARED, {}), restartPageViewTracking && (this.stopPageViewTracking = this.activity.autoTrackPageViews());
+  }
+  getBusinessId() {
+    return this.businessId;
+  }
+  async resolveBusinessId() {
+    if (this.businessId)
+      return this.businessId;
+    if (this.businessIdResolvePromise)
+      return this.businessIdResolvePromise;
+    let publicKeyEpoch = this.publicKeyEpoch, resolution = (async () => {
+      let result = await this.business.getInfo();
+      if (!result.ok || !result.value?.id)
+        throw new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.ErrorCode.NOT_FOUND,
+          "Unable to resolve business ID from the current public key.",
+          true
+        );
+      if (this.publicKeyEpoch !== publicKeyEpoch)
+        throw new chunkUCR5HRYM_js.CimplifyError(
+          chunkUCR5HRYM_js.ErrorCode.TENANT_CONTEXT_CHANGED,
+          "The storefront tenant changed while resolving its business identity.",
+          true
+        );
+      return this.businessId = result.value.id, result.value.id;
+    })();
+    this.businessIdResolvePromise = resolution;
+    try {
+      return await resolution;
+    } finally {
+      this.businessIdResolvePromise === resolution && (this.businessIdResolvePromise = null);
+    }
+  }
+  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
+  // constructor at module load, so a throw would white-screen the whole app —
+  // fall back to an in-memory session token instead.
+  safeStorage() {
+    try {
+      if (typeof window < "u" && window.localStorage)
+        return window.localStorage;
+    } catch {
+    }
+    return null;
+  }
+  loadSessionToken() {
+    try {
+      return this.safeStorage()?.getItem(SESSION_TOKEN_STORAGE_KEY) ?? null;
+    } catch {
+      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
+   * different server-minted token and last-writer-wins splits the session
+   * (cart writes and chat conversations land on dropped tokens).
+   *
+   * Browser-only: minting on a server-shared client instance would pin
+   * every visitor to one session, so SSR keeps the lazy server-minted flow.
+   */
+  mintSessionToken() {
+    if (typeof window > "u")
+      return null;
+    let token = generateSessionToken();
+    return this.saveSessionToken(token), token;
+  }
+  saveSessionToken(token) {
+    try {
+      this.safeStorage()?.setItem(SESSION_TOKEN_STORAGE_KEY, token);
+    } catch {
+    }
+  }
+  captureSessionToken(response) {
+    if (typeof window > "u" || this.sessionToken) return;
+    let token = response.headers.get(SESSION_TOKEN_HEADER);
+    token && (this.sessionToken = token, this.saveSessionToken(token));
+  }
+  getHeaders() {
+    let headers = {
+      "Content-Type": "application/json"
+    }, trimmedPublicKey = this.publicKey.trim();
+    if (trimmedPublicKey && (headers["X-API-Key"] = trimmedPublicKey), this.accessToken && (headers.Authorization = `Bearer ${this.accessToken}`), this.sessionToken && (headers[SESSION_TOKEN_HEADER] = this.sessionToken), typeof window < "u") {
+      headers["X-Storefront-Host"] = window.location.host;
+      let preview = new URLSearchParams(window.location.search).get("preview");
+      preview && (headers["X-Storefront-Preview"] = preview);
+    }
+    return headers;
+  }
+  async resilientFetch(url, options, timeoutMs, retryPolicy, signal) {
+    let method = options.method || "GET", path = url.replace(this.baseUrl, "").replace(this.linkApiUrl, ""), startTime = Date.now(), retryCount = 0, context = {
+      method,
+      path,
+      url,
+      body: options.body ? JSON.parse(options.body) : void 0,
+      startTime
+    };
+    this.hooks.onRequestStart?.(context);
+    let lastError, configuredMaxRetries = Math.max(0, Math.floor(this.maxRetries)), maxRetries = Math.min(
+      configuredMaxRetries,
+      Math.max(0, Math.floor(retryPolicy?.maxRetries ?? configuredMaxRetries))
+    ), jitterRatio = retryPolicy?.jitterRatio ?? 0;
+    for (let attempt = 0; attempt <= maxRetries; attempt++)
+      try {
+        if (signal?.aborted)
+          throw new chunkUCR5HRYM_js.CimplifyError(chunkUCR5HRYM_js.ErrorCode.CANCELLED, "Request was cancelled.", !0);
+        let controller = new AbortController(), timeoutId = setTimeout(() => controller.abort(), timeoutMs ?? this.timeout), onAbort = () => controller.abort();
+        signal?.addEventListener("abort", onAbort, { once: !0 });
+        let response;
+        try {
+          response = await this.fetchImpl(url, {
+            ...options,
+            signal: controller.signal
+          });
+        } finally {
+          clearTimeout(timeoutId), signal?.removeEventListener("abort", onAbort);
+        }
+        if (this.captureSessionToken(response), response.ok)
+          return this.hooks.onRequestSuccess?.({
+            ...context,
+            status: response.status,
+            durationMs: Date.now() - startTime
+          }), response;
+        if (response.status === (503) && attempt < maxRetries) {
+          retryCount++;
+          let retryAfterMs = parseRetryAfterMs(response.headers.get(RETRY_AFTER_HEADER)), retryBaseMs = retryAfterMs ?? this.retryDelay * Math.pow(2, attempt), jitteredDelayMs = withPositiveJitter(retryBaseMs, jitterRatio), delay = retryAfterMs === null ? jitteredDelayMs : Math.min(jitteredDelayMs, (3e4));
+          this.hooks.onRetry?.({
+            ...context,
+            attempt: retryCount,
+            delayMs: delay,
+            error: new Error(`Retryable: ${response.status}`)
+          }), await sleep(delay, signal);
+          continue;
+        }
+        if (response.status >= 400 && response.status < 500)
+          return this.hooks.onRequestError?.({
+            ...context,
+            error: new chunkUCR5HRYM_js.CimplifyError(
+              `HTTP_${response.status}`,
+              `Request failed with status ${response.status}`,
+              !1
+            ),
+            status: response.status,
+            durationMs: Date.now() - startTime,
+            retryCount,
+            retryable: !1
+          }), response;
+        if (response.status >= 500 && attempt < maxRetries) {
+          retryCount++;
+          let 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, signal);
+          continue;
+        }
+        return this.hooks.onRequestError?.({
+          ...context,
+          error: new chunkUCR5HRYM_js.CimplifyError(
+            chunkUCR5HRYM_js.ErrorCode.SERVER_ERROR,
+            `Server error ${response.status} after ${retryCount} retries`,
+            !1
+          ),
+          status: response.status,
+          durationMs: Date.now() - startTime,
+          retryCount,
+          retryable: !1
+        }), response;
+      } catch (error) {
+        if (lastError = error, signal?.aborted)
+          throw new chunkUCR5HRYM_js.CimplifyError(chunkUCR5HRYM_js.ErrorCode.CANCELLED, "Request was cancelled.", true);
+        let networkError = toNetworkError(error, this.isTestMode()), errorRetryable = isRetryable(error);
+        if (!errorRetryable || attempt >= maxRetries)
+          throw this.hooks.onRequestError?.({
+            ...context,
+            error: networkError,
+            durationMs: Date.now() - startTime,
+            retryCount,
+            retryable: errorRetryable
+          }), networkError;
+        retryCount++;
+        let delay = withPositiveJitter(this.retryDelay * Math.pow(2, attempt), jitterRatio);
+        this.hooks.onRetry?.({
+          ...context,
+          attempt: retryCount,
+          delayMs: delay,
+          error: networkError
+        }), await sleep(delay, signal);
+      }
+    let finalError = toNetworkError(lastError, this.isTestMode());
+    throw this.hooks.onRequestError?.({
+      ...context,
+      error: finalError,
+      durationMs: Date.now() - startTime,
+      retryCount,
+      retryable: false
+    }), finalError;
+  }
+  getDedupeKey(type, payload, cacheOptions) {
+    let cacheKey = cacheOptions ? `|${JSON.stringify(cacheOptions)}` : "", identityKey = JSON.stringify([
+      this.publicKey.trim(),
+      this.publicKeyEpoch,
+      this.sessionEpoch,
+      this.context.location_id ?? null
+    ]);
+    return `${type}:${identityKey}:${JSON.stringify(payload)}${cacheKey}`;
+  }
+  async deduplicatedRequest(key, requestFn) {
+    let existing = this.inflightRequests.get(key);
+    if (existing)
+      return existing;
+    let request = requestFn().finally(() => {
+      this.inflightRequests.get(key) === request && this.inflightRequests.delete(key);
+    });
+    return this.inflightRequests.set(key, request), request;
+  }
+  async get(path, opts) {
+    let request = async () => {
+      let 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();
+    let key = this.getDedupeKey("get", path, opts?.cacheOptions);
+    return this.deduplicatedRequest(key, request);
+  }
+  async post(path, body, opts) {
+    let response = await this.authedFetch(
+      this.buildUrl(this.baseUrl, path),
+      {
+        method: "POST",
+        credentials: this.credentials,
+        headers: mergeOptionHeaders(this.getHeaders(), opts),
+        body: body ? JSON.stringify(body) : void 0
+      },
+      opts?.timeoutMs,
+      opts?.retryPolicy,
+      opts?.signal
+    );
+    return this.handleRestResponse(response);
+  }
+  async patch(path, body, opts) {
+    let response = await this.authedFetch(
+      this.buildUrl(this.baseUrl, path),
+      {
+        method: "PATCH",
+        credentials: this.credentials,
+        headers: mergeOptionHeaders(this.getHeaders(), opts),
+        body: body ? JSON.stringify(body) : void 0
+      },
+      opts?.timeoutMs,
+      opts?.retryPolicy,
+      opts?.signal
+    );
+    return this.handleRestResponse(response);
+  }
+  async delete(path, opts) {
+    let response = await this.authedFetch(
+      this.buildUrl(this.baseUrl, path),
+      {
+        method: "DELETE",
+        credentials: this.credentials,
+        headers: mergeOptionHeaders(this.getHeaders(), opts)
+      },
+      opts?.timeoutMs,
+      opts?.retryPolicy,
+      opts?.signal
+    );
+    return this.handleRestResponse(response);
+  }
+  async linkGet(path, opts) {
+    let request = async () => {
+      let 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();
+    let key = this.getDedupeKey("linkGet", path, opts?.cacheOptions);
+    return this.deduplicatedRequest(key, request);
+  }
+  async linkPost(path, body, opts) {
+    let response = await this.authedFetch(
+      `${this.linkApiUrl}${path}`,
+      {
+        method: "POST",
+        credentials: this.credentials,
+        headers: mergeOptionHeaders(this.getHeaders(), opts),
+        body: body ? JSON.stringify(body) : void 0
+      },
+      opts?.timeoutMs,
+      opts?.retryPolicy,
+      opts?.signal
+    );
+    return this.handleRestResponse(response);
+  }
+  async linkDelete(path, opts) {
+    let 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) {
+    let serverFailure = response.status >= (500), json;
+    try {
+      json = await response.json();
+    } catch {
+      throw chunkUCR5HRYM_js.enrichError(
+        new chunkUCR5HRYM_js.CimplifyError(
+          serverFailure ? chunkUCR5HRYM_js.ErrorCode.SERVER_ERROR : chunkUCR5HRYM_js.ErrorCode.API_ERROR,
+          serverFailure ? "The service is temporarily unavailable." : "The service returned an unreadable response.",
+          serverFailure
+        ),
+        { isTestMode: this.isTestMode() }
+      );
+    }
+    if (!response.ok) {
+      let errorCode = typeof json.error == "object" && json.error?.error_code || typeof json.error == "object" && json.error?.code || chunkUCR5HRYM_js.ErrorCode.API_ERROR, 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", retryable = typeof json.error == "object" && typeof json.error?.retryable == "boolean" ? json.error.retryable : serverFailure;
+      if (errorCode === chunkUCR5HRYM_js.ErrorCode.IDEMPOTENCY_MISMATCH) {
+        let originalCreatedAt = typeof json.error == "object" && json.error?.original_created_at || "";
+        throw new chunkUCR5HRYM_js.IdempotencyMismatchError(errorMessage, originalCreatedAt);
+      }
+      let error = chunkUCR5HRYM_js.enrichError(new chunkUCR5HRYM_js.CimplifyError(errorCode, errorMessage, retryable), {
+        isTestMode: this.isTestMode()
+      });
+      if (response.status === (429)) {
+        let retryAfterMs = retryAfterDelayMs(response.headers.get(RETRY_AFTER_HEADER));
+        retryAfterMs !== null && (error.retryAfterMs = retryAfterMs);
+      }
+      throw (response.status === 401 || error.code === chunkUCR5HRYM_js.ErrorCode.UNAUTHORIZED) && this.accessToken && console.warn(
+        "[Cimplify] Received 401 Unauthorized. Access token may be missing/expired. Refresh authentication and retry the request."
+      ), error;
+    }
+    if (json?.success === false || json?.error?.code || json?.error?.message)
+      throw chunkUCR5HRYM_js.enrichError(
+        new chunkUCR5HRYM_js.CimplifyError(
+          json.error?.code || chunkUCR5HRYM_js.ErrorCode.API_ERROR,
+          json.error?.message || "An error occurred",
+          json.error?.retryable || false
+        ),
+        { isTestMode: this.isTestMode() }
+      );
+    return json?.data !== void 0 ? json.data : json;
+  }
+  get catalogue() {
+    return this._catalogue || (this._catalogue = new chunkOMTVH334_js.CatalogueQueries(this)), this._catalogue;
+  }
+  get cart() {
+    return this._cart || (this._cart = new chunkOMTVH334_js.CartOperations(this)), this._cart;
+  }
+  get checkout() {
+    return this._checkout || (this._checkout = new chunkOMTVH334_js.CheckoutService(this)), this._checkout;
+  }
+  get purchaseIntents() {
+    return this._purchaseIntents || (this._purchaseIntents = new PurchaseIntentService(this)), this._purchaseIntents;
+  }
+  get orders() {
+    return this._orders || (this._orders = new chunkOMTVH334_js.OrderQueries(this)), this._orders;
+  }
+  get storeCredit() {
+    return this._storeCredit || (this._storeCredit = new StoreCreditQueries(this)), this._storeCredit;
+  }
+  get subscriptions() {
+    return this._subscriptions || (this._subscriptions = new SubscriptionService(this)), this._subscriptions;
+  }
+  get uploads() {
+    return this._uploads || (this._uploads = new UploadService(this)), this._uploads;
+  }
+  get places() {
+    return this._places || (this._places = new PlacesService(this)), this._places;
+  }
+  get link() {
+    return this._link || (this._link = new chunkOMTVH334_js.LinkService(this)), this._link;
+  }
+  get auth() {
+    return this._auth || (this._auth = new chunkOMTVH334_js.AuthService(this)), this._auth;
+  }
+  get business() {
+    return this._business || (this._business = new chunkOMTVH334_js.BusinessService(this)), this._business;
+  }
+  get inventory() {
+    return this._inventory || (this._inventory = new chunkOMTVH334_js.InventoryService(this)), this._inventory;
+  }
+  get scheduling() {
+    return this._scheduling || (this._scheduling = new chunkOMTVH334_js.SchedulingService(this)), this._scheduling;
+  }
+  get lite() {
+    return this._lite || (this._lite = new chunkOMTVH334_js.LiteService(this)), this._lite;
+  }
+  get fx() {
+    return this._fx || (this._fx = new chunkOMTVH334_js.FxService(this)), this._fx;
+  }
+  get activity() {
+    return this._activity || (this._activity = new ActivityService(this)), this._activity;
+  }
+  get delivery() {
+    return this._delivery || (this._delivery = new DeliveryService(this)), this._delivery;
+  }
+  get support() {
+    return this._support || (this._support = new SupportService(this)), this._support;
+  }
+  get session() {
+    return this._session || (this._session = new SessionService(this)), this._session;
+  }
+  buildWsUrl(path) {
+    let protocol = this.baseUrl.startsWith("https") ? "wss:" : "ws:", host = this.baseUrl.replace(/^https?:\/\//, ""), params = new URLSearchParams();
+    this.publicKey && params.set("api_key", this.publicKey), this.sessionToken && params.set("session_token", this.sessionToken);
+    let query = params.toString();
+    return `${protocol}//${host}${path}${query ? `?${query}` : ""}`;
+  }
+  elements(businessId, options) {
+    return businessId && this.setBusinessId(businessId), chunkOMTVH334_js.createElements(this, businessId ?? this.businessId ?? void 0, options);
+  }
+};
+function createCimplifyClient(config = {}) {
+  return new CimplifyClient(config);
+}
+
+exports.ActivityService = ActivityService;
+exports.CONTENT_SHA256_HEADER = CONTENT_SHA256_HEADER;
+exports.CimplifyClient = CimplifyClient;
+exports.DeliveryService = DeliveryService;
+exports.HostedPurchaseIntentService = HostedPurchaseIntentService;
+exports.PURCHASE_INTENT_ROUTE = PURCHASE_INTENT_ROUTE;
+exports.PlacesService = PlacesService;
+exports.PurchaseIntentResolver = PurchaseIntentResolver;
+exports.PurchaseIntentService = PurchaseIntentService;
+exports.SESSION_CHANGE_SOURCE = SESSION_CHANGE_SOURCE;
+exports.SessionService = SessionService;
+exports.StoreCreditQueries = StoreCreditQueries;
+exports.SubscriptionService = SubscriptionService;
+exports.SupportService = SupportService;
+exports.UploadService = UploadService;
+exports.chatRealtimeUpdateFromWire = chatRealtimeUpdateFromWire;
+exports.contentSha256 = contentSha256;
+exports.createCimplifyClient = createCimplifyClient;
+exports.isTransientPurchaseIntentError = isTransientPurchaseIntentError;