@cimplify/sdk 0.102.0 → 0.104.0

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

@@ -1,5 +1,6 @@
-import { safe, generateIdempotencyKey, err, ok, CatalogueQueries, CartOperations, CheckoutService, OrderQueries, LinkService, AuthService, BusinessService, InventoryService, SchedulingService, LiteService, FxService, createElements } from './chunk-Z3K2D3TE.mjs';
-import { CimplifyError, ErrorCode, IdempotencyMismatchError, enrichError } from './chunk-O3YUHLZL.mjs';
+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';
 
 // src/store-credit.ts
 var StoreCreditQueries = class {
@@ -206,6 +207,7 @@ var ActivityService = class {
       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,
@@ -414,14 +416,14 @@ var UploadService = class {
   constructor(client) {
     this.client = client;
   }
-  async init(filename, contentType, sizeBytes, opts) {
+  async init(filename, contentType2, sizeBytes, opts) {
     const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
     return safe(
       this.client.post(
         "/api/v1/uploads/init",
         {
           filename,
-          content_type: contentType,
+          content_type: contentType2,
           size_bytes: sizeBytes
         },
         { idempotencyKey }
@@ -522,6 +524,99 @@ var DeliveryService = class {
   }
 };
 
+// src/chat-wire.ts
+function senderType(message) {
+  if (message.sender_side === "account") return "customer";
+  if (message.sender_side === "system") return "system";
+  return 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") {
+    const mime = message.media[0]?.mime_type ?? "";
+    if (mime.startsWith("image/")) return "image";
+    if (mime.startsWith("video/")) return "video";
+    if (mime.startsWith("audio/")) return "audio";
+    return "document";
+  }
+  return "text";
+}
+function unresolvedReply(id) {
+  return { id, sender_type: "system", preview: "Earlier message" };
+}
+function chatMessagesFromWire(messages) {
+  const 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
+  }));
+  const byId = new Map(converted.map((message) => [message.id, message]));
+  return converted.map((message) => {
+    const targetId = message.reply_to?.id;
+    const target = targetId ? byId.get(targetId) : void 0;
+    if (!targetId || !target) return message;
+    return {
+      ...message,
+      reply_to: {
+        id: targetId,
+        sender_type: target.sender_type,
+        preview: 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) {
+    const read = envelope.data;
+    if (read.reader_side === "business" && typeof read.occurred_at === "string") {
+      return { kind: "business_read", occurredAt: read.occurred_at };
+    }
+    return { kind: "none" };
+  }
+  if (envelope.type === "history_imported") {
+    return { kind: "reload" };
+  }
+  if (envelope.type === "ai_mode_changed" && envelope.data) {
+    const mode = envelope.data.mode;
+    if (mode === "auto" || mode === "assist" || mode === "off") {
+      return { kind: "ai_mode", mode };
+    }
+    return { kind: "none" };
+  }
+  if (envelope.type === "handoff_requested") {
+    return { kind: "handoff" };
+  }
+  if (envelope.type === "resync") {
+    return { kind: "resync", latestSequence: envelope.latest_sequence };
+  }
+  return { kind: "none" };
+}
+
 // src/internal/events.ts
 var MUTATION_ERROR = "mutation:error";
 var AUTH_TOKEN_CHANGED = "auth:token-changed";
@@ -584,11 +679,13 @@ var SupportService = class {
    * Claim the anonymous session for the verified Link identity: the server
    * verifies the access token, rotates the session token (adopted here, so
    * every subsequent request rides the bound session), folds the guest cart
-   * in, and adopts or merges the widget conversation.
+   * in, and opens or reuses the account's canonical direct Chat thread.
    *
    * Idempotent and single-flight: concurrent calls share one request, and a
    * token already claimed by this instance short-circuits without a network
-   * round trip. Emits `session:claimed` on the client's event channel.
+   * 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 claimConversation() {
     const accessToken = this.client.getAccessToken();
@@ -625,7 +722,7 @@ var SupportService = class {
         this.client.publishSessionClaimed(this.claimedName);
         this.client.events.emit(SESSION_CLAIMED, {
           sessionToken: result.value.session_token,
-          threadId: result.value.thread_id ?? null,
+          threadId: result.value.thread.id,
           customerName: result.value.customer_name
         });
       }
@@ -638,6 +735,25 @@ var SupportService = class {
       this.claimInFlightToken = null;
     }
   }
+  /**
+   * 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() {
+    if (!this.client.getAccessToken()) {
+      return err(new CimplifyError("not_authenticated", "No access token to claim with"));
+    }
+    return safe(
+      (async () => {
+        const businessId = await this.client.resolveBusinessId();
+        return this.client.post("/v1/me/chats/external-claims", {
+          business_id: businessId
+        });
+      })()
+    );
+  }
   /**
    * Peek at the conversation without creating one: resolves the existing
    * thread (or null) so a page load can hydrate history without littering
@@ -651,17 +767,22 @@ var SupportService = class {
     if (!result.value.conversation) return ok(null);
     return ok({
       conversation: result.value.conversation,
-      messages: result.value.messages
+      messages: chatMessagesFromWire(result.value.messages)
     });
   }
   /** Open (or resume) the customer's widget conversation. */
   async openConversation(opts) {
     const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
+    const result = await safe(
       this.client.post("/api/v1/support/conversation", void 0, {
         idempotencyKey
       })
     );
+    if (!result.ok) return result;
+    return ok({
+      conversation: result.value.conversation,
+      messages: chatMessagesFromWire(result.value.messages)
+    });
   }
   /**
    * Send a message in the active conversation.
@@ -673,7 +794,7 @@ var SupportService = class {
    */
   async sendMessage(content, opts) {
     const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
+    const result = await safe(
       this.client.post(
         "/api/v1/support/conversation/messages",
         {
@@ -685,6 +806,7 @@ var SupportService = class {
         { idempotencyKey }
       )
     );
+    return result.ok ? ok(chatMessageFromWire(result.value.message)) : result;
   }
   /**
    * Poll for messages. `after` pages forward (live updates); `before` pages
@@ -692,21 +814,27 @@ var SupportService = class {
    */
   async getMessages(options = {}) {
     const params = new URLSearchParams();
-    if (options.after) params.set("after", options.after);
-    if (options.before) params.set("before", options.before);
+    if (options.afterSequence !== void 0)
+      params.set("after_sequence", String(options.afterSequence));
+    if (options.beforeSequence !== void 0)
+      params.set("before_sequence", String(options.beforeSequence));
     if (options.limit) params.set("limit", String(options.limit));
     const query = params.toString();
     const path = query ? `/api/v1/support/conversation/messages?${query}` : "/api/v1/support/conversation/messages";
-    return safe(this.client.get(path));
+    const result = await safe(this.client.get(path));
+    return result.ok ? ok(chatMessagesFromWire(result.value)) : result;
   }
   /** React to a message in the active conversation by its `ChatMessage.id`. */
   async reactToMessage(messageId, emoji) {
-    return safe(
+    const clientId = generateIdempotencyKey();
+    const result = await safe(
       this.client.post(
         `/api/v1/support/conversation/messages/${messageId}/reactions`,
-        { emoji }
+        { emoji, client_id: clientId },
+        { idempotencyKey: clientId }
       )
     );
+    return result.ok ? ok(chatMessageFromWire(result.value.message)) : result;
   }
   /** Ask for a person: flags the thread for the merchant's inbox. */
   async requestHuman(opts) {
@@ -721,6 +849,456 @@ 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" });
+    }
+  });
+}
+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
+    };
+  }
+};
+
+// src/payment-authorization/providers/stripe.ts
+async function loadStripeFromPeer(publicKey, options) {
+  try {
+    const imported = await import('@stripe/stripe-js');
+    return imported.loadStripe ? imported.loadStripe(publicKey, options) : 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 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 };
+}
+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
+      };
+    }
+    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() : "";
+}
+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 createDefaultPaymentAuthorizationAdapterRegistry() {
+  return new PaymentAuthorizationAdapterRegistry([
+    new PaystackAuthorizationAdapter(),
+    new StripeAuthorizationAdapter()
+  ]);
+}
+
 // src/client.ts
 var SESSION_TOKEN_STORAGE_KEY = "cimplify_session_token";
 var SESSION_SYNC_STORAGE_KEY = "cimplify_session_sync";
@@ -845,6 +1423,7 @@ var CimplifyClient = class {
     this.context = {};
     this.businessId = null;
     this.businessIdResolvePromise = null;
+    this.publicKeyEpoch = 0;
     this.inflightRequests = /* @__PURE__ */ new Map();
     /**
      * App-level event channel. Subscribe to surface mutation rollbacks, outbox
@@ -863,6 +1442,7 @@ var CimplifyClient = class {
     this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
     this.retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
     this.hooks = config.hooks ?? {};
+    this.authorizationAdapters = config.authorizationAdapterRegistry ?? createDefaultPaymentAuthorizationAdapterRegistry();
     this.fetchImpl = (config.fetch ?? globalThis.fetch).bind(globalThis);
     this.sessionToken = this.loadSessionToken() ?? this.mintSessionToken();
     this.watchCrossTabSession();
@@ -928,7 +1508,8 @@ var CimplifyClient = class {
    * 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
-   * auth flows, never by the raw token setter.
+   * merchant auth flows, never by the raw token setter. Global Link clients
+   * have no storefront tenant and therefore activate without this step.
    */
   autoClaimChatIdentity() {
     if (typeof window === "undefined" || !this.sessionToken || !this.accessToken) return;
@@ -970,9 +1551,28 @@ var CimplifyClient = class {
   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 {
+      const raw = this.safeStorage()?.getItem(SESSION_SYNC_STORAGE_KEY);
+      if (!raw) return false;
+      const payload = JSON.parse(raw);
+      return payload.type === "claimed" && payload.token === this.sessionToken;
+    } catch {
+      return false;
+    }
+  }
   publishSessionClaimed(customerName) {
     if (!this.sessionToken) return;
     this.broadcastSessionSync({
@@ -1079,10 +1679,18 @@ var CimplifyClient = class {
   // X-API-Key and the business can't be resolved.
   setPublicKey(publicKey) {
     const normalized = publicKey.trim();
-    if (!normalized) {
-      return;
-    }
+    if (normalized === this.publicKey) return;
     this.publicKey = normalized;
+    this.publicKeyEpoch += 1;
+    this.businessId = null;
+    this.businessIdResolvePromise = null;
+    this.inflightRequests.clear();
+    this._activity?.resetSession();
+    delete this.context.location_id;
+    if (this.accessToken !== null) {
+      this.setAccessToken(null);
+    }
+    this.events.emit(SESSION_CLEARED, {});
   }
   getBusinessId() {
     return this.businessId;
@@ -1094,7 +1702,8 @@ var CimplifyClient = class {
     if (this.businessIdResolvePromise) {
       return this.businessIdResolvePromise;
     }
-    this.businessIdResolvePromise = (async () => {
+    const publicKeyEpoch = this.publicKeyEpoch;
+    const resolution = (async () => {
       const result = await this.business.getInfo();
       if (!result.ok || !result.value?.id) {
         throw new CimplifyError(
@@ -1103,13 +1712,23 @@ var CimplifyClient = class {
           true
         );
       }
+      if (this.publicKeyEpoch !== publicKeyEpoch) {
+        throw new CimplifyError(
+          ErrorCode.TENANT_CONTEXT_CHANGED,
+          "The storefront tenant changed while resolving its business identity.",
+          true
+        );
+      }
       this.businessId = result.value.id;
       return result.value.id;
     })();
+    this.businessIdResolvePromise = resolution;
     try {
-      return await this.businessIdResolvePromise;
+      return await resolution;
     } finally {
-      this.businessIdResolvePromise = null;
+      if (this.businessIdResolvePromise === resolution) {
+        this.businessIdResolvePromise = null;
+      }
     }
   }
   async authedFetch(url, options, timeoutMs) {
@@ -1312,7 +1931,13 @@ var CimplifyClient = class {
   }
   getDedupeKey(type, payload, cacheOptions) {
     const cacheKey = cacheOptions ? `|${JSON.stringify(cacheOptions)}` : "";
-    return `${type}:${JSON.stringify(payload)}${cacheKey}`;
+    const 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) {
     const existing = this.inflightRequests.get(key);
@@ -1320,7 +1945,9 @@ var CimplifyClient = class {
       return existing;
     }
     const request = requestFn().finally(() => {
-      this.inflightRequests.delete(key);
+      if (this.inflightRequests.get(key) === request) {
+        this.inflightRequests.delete(key);
+      }
     });
     this.inflightRequests.set(key, request);
     return request;
@@ -1572,4 +2199,4 @@ function createCimplifyClient(config = {}) {
   return new CimplifyClient(config);
 }
 
-export { AUTH_TOKEN_CHANGED, ActivityService, CimplifyClient, DeliveryService, MUTATION_ERROR, PlacesService, SESSION_CLAIMED, SESSION_CLEARED, StoreCreditQueries, SubscriptionService, SupportService, UploadService, createCimplifyClient };
+export { AUTH_TOKEN_CHANGED, ActivityService, CimplifyClient, DeliveryService, MUTATION_ERROR, PaymentAuthorizationAdapterRegistry, PaystackAuthorizationAdapter, PlacesService, SESSION_CLAIMED, SESSION_CLEARED, StoreCreditQueries, StripeAuthorizationAdapter, SubscriptionService, SupportService, UploadService, chatRealtimeUpdateFromWire, createCimplifyClient, createDefaultPaymentAuthorizationAdapterRegistry };