@cimplify/sdk 0.108.0 → 0.110.2

package/dist/chunk-F7J3HK27.js

@@ -1,4549 +0,0 @@
-'use strict';
-
-var chunkEV2EVOYS_js = require('./chunk-EV2EVOYS.js');
-var chunkV32BCG7M_js = require('./chunk-V32BCG7M.js');
-var chunkANT574FD_js = require('./chunk-ANT574FD.js');
-
-// src/types/result.ts
-function ok(value) {
-  return { ok: true, value };
-}
-function err(error) {
-  return { ok: false, error };
-}
-function isOk(result) {
-  return result.ok === true;
-}
-function isErr(result) {
-  return result.ok === false;
-}
-function mapResult(result, fn) {
-  return result.ok ? ok(fn(result.value)) : result;
-}
-function mapError(result, fn) {
-  return result.ok ? result : err(fn(result.error));
-}
-function flatMap(result, fn) {
-  return result.ok ? fn(result.value) : result;
-}
-function getOrElse(result, defaultFn) {
-  return result.ok ? result.value : defaultFn();
-}
-function unwrap(result) {
-  if (result.ok) {
-    return result.value;
-  }
-  throw result.error;
-}
-function toNullable(result) {
-  return result.ok ? result.value : void 0;
-}
-async function fromPromise(promise, mapError2) {
-  try {
-    const value = await promise;
-    return ok(value);
-  } catch (error) {
-    return err(mapError2(error));
-  }
-}
-function tryCatch(fn, mapError2) {
-  try {
-    return ok(fn());
-  } catch (error) {
-    return err(mapError2(error));
-  }
-}
-function combine(results) {
-  const values = [];
-  for (const result of results) {
-    if (!result.ok) {
-      return result;
-    }
-    values.push(result.value);
-  }
-  return ok(values);
-}
-function combineObject(results) {
-  const values = {};
-  for (const [key, result] of Object.entries(results)) {
-    if (!result.ok) {
-      return result;
-    }
-    values[key] = result.value;
-  }
-  return ok(values);
-}
-
-// src/internal/idempotency.ts
-function generateIdempotencyKey(prefix = "idem") {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return `${prefix}_${crypto.randomUUID()}`;
-  }
-  const timestamp = Date.now().toString(36);
-  const random = Math.random().toString(36).substring(2, 15);
-  return `${prefix}_${timestamp}_${random}`;
-}
-var INTENT_PREFIX = "cimplify-intent:";
-function sessionStorageOrNull() {
-  try {
-    return typeof window !== "undefined" ? window.sessionStorage : null;
-  } catch {
-    return null;
-  }
-}
-function intentIdempotencyKey(scope, fingerprint, storage = sessionStorageOrNull()) {
-  const slot = INTENT_PREFIX + scope;
-  try {
-    const raw = storage?.getItem(slot);
-    if (raw) {
-      const stored = JSON.parse(raw);
-      if (stored.fingerprint === fingerprint && typeof stored.key === "string") return stored.key;
-    }
-  } catch {
-  }
-  const key = generateIdempotencyKey();
-  try {
-    storage?.setItem(slot, JSON.stringify({ key, fingerprint }));
-  } catch {
-  }
-  return key;
-}
-function clearIntentIdempotencyKey(scope, storage = sessionStorageOrNull()) {
-  try {
-    storage?.removeItem(INTENT_PREFIX + scope);
-  } catch {
-  }
-}
-
-// src/internal/safe.ts
-function toCimplifyError(error) {
-  if (error instanceof chunkANT574FD_js.CimplifyError) return chunkANT574FD_js.enrichError(error);
-  if (error instanceof Error) {
-    return chunkANT574FD_js.enrichError(new chunkANT574FD_js.CimplifyError(chunkANT574FD_js.ErrorCode.UNKNOWN_ERROR, error.message, false));
-  }
-  return chunkANT574FD_js.enrichError(new chunkANT574FD_js.CimplifyError(chunkANT574FD_js.ErrorCode.UNKNOWN_ERROR, String(error), false));
-}
-async function safe(promise) {
-  try {
-    return ok(await promise);
-  } catch (error) {
-    return err(toCimplifyError(error));
-  }
-}
-
-// src/catalogue.ts
-function withQuery(path, params) {
-  const query = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value === void 0) continue;
-    query.set(key, String(value));
-  }
-  const queryString = query.toString();
-  return queryString ? `${path}?${queryString}` : path;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function readFinalPrice(value) {
-  if (!isRecord(value)) return void 0;
-  const finalPrice = value.final_price;
-  if (typeof finalPrice === "string" || typeof finalPrice === "number") {
-    return finalPrice;
-  }
-  return void 0;
-}
-function needsDefaultPriceNormalization(value) {
-  return value === void 0 || value === null || value === "";
-}
-function optionNeedsNormalization(option) {
-  return isRecord(option) && needsDefaultPriceNormalization(option["default_price"]);
-}
-function addOnNeedsNormalization(addOn) {
-  if (!isRecord(addOn)) return false;
-  const options = addOn["options"];
-  return Array.isArray(options) && options.some((option) => optionNeedsNormalization(option));
-}
-function normalizeAddOnPayload(addOn) {
-  if (!isRecord(addOn)) return addOn;
-  const options = addOn["options"];
-  if (!Array.isArray(options)) return addOn;
-  if (!options.some((option) => optionNeedsNormalization(option))) return addOn;
-  const normalizedAddOn = { ...addOn };
-  normalizedAddOn["options"] = options.map((option) => {
-    if (!isRecord(option)) return option;
-    if (!optionNeedsNormalization(option)) return option;
-    const normalizedOption = { ...option };
-    const optionPrice = normalizedOption["default_price"];
-    if (needsDefaultPriceNormalization(optionPrice)) {
-      normalizedOption["default_price"] = readFinalPrice(normalizedOption["default_price_info"]) || readFinalPrice(normalizedOption["price_info"]) || "0";
-    }
-    return normalizedOption;
-  });
-  return normalizedAddOn;
-}
-function normalizeCatalogueProductPayload(product) {
-  const productRecord = product;
-  const defaultPrice = productRecord["default_price"];
-  const addOns = productRecord["add_ons"];
-  const needsPriceFix = needsDefaultPriceNormalization(defaultPrice);
-  const needsAddOnFix = Array.isArray(addOns) && addOns.some((addOn) => addOnNeedsNormalization(addOn));
-  if (!needsPriceFix && !needsAddOnFix) {
-    return product;
-  }
-  const normalized = { ...productRecord };
-  if (needsPriceFix) {
-    const derivedDefaultPrice = readFinalPrice(normalized["default_price_info"]) || readFinalPrice(normalized["price_info"]) || (typeof normalized["final_price"] === "string" || typeof normalized["final_price"] === "number" ? normalized["final_price"] : void 0);
-    normalized["default_price"] = derivedDefaultPrice ?? "0";
-  }
-  if (needsAddOnFix && Array.isArray(addOns)) {
-    normalized["add_ons"] = addOns.map((addOn) => normalizeAddOnPayload(addOn));
-  }
-  return normalized;
-}
-function toFiniteNumber(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string" && value.trim().length > 0) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
-  }
-  return void 0;
-}
-function normalizePagination(value) {
-  if (!isRecord(value)) {
-    return void 0;
-  }
-  const totalCount = toFiniteNumber(value.total_count);
-  const currentPage = toFiniteNumber(value.current_page);
-  const pageSize = toFiniteNumber(value.page_size);
-  const totalPages = toFiniteNumber(value.total_pages);
-  if (totalCount === void 0 || currentPage === void 0 || pageSize === void 0 || totalPages === void 0) {
-    return void 0;
-  }
-  return {
-    total_count: totalCount,
-    current_page: currentPage,
-    page_size: pageSize,
-    total_pages: totalPages,
-    has_more: value.has_more === true,
-    next_cursor: typeof value.next_cursor === "string" ? value.next_cursor : void 0
-  };
-}
-function normalizeCatalogueResult(payload) {
-  if (Array.isArray(payload)) {
-    return {
-      items: payload.map((product) => normalizeCatalogueProductPayload(product)),
-      is_complete: true
-    };
-  }
-  if (!isRecord(payload)) {
-    return {
-      items: [],
-      is_complete: true
-    };
-  }
-  const rawItems = Array.isArray(payload.products) ? payload.products : Array.isArray(payload.items) ? payload.items : [];
-  return {
-    items: rawItems.map((product) => normalizeCatalogueProductPayload(product)),
-    is_complete: typeof payload.is_complete === "boolean" ? payload.is_complete : true,
-    total_available: toFiniteNumber(payload.total_available),
-    pagination: normalizePagination(payload.pagination)
-  };
-}
-function normalizeCatalogueSnapshot(payload) {
-  if (Array.isArray(payload)) {
-    return {
-      categories: [],
-      products: payload.map((product) => normalizeCatalogueProductPayload(product)),
-      add_ons: [],
-      is_complete: true
-    };
-  }
-  if (!isRecord(payload)) {
-    return {
-      categories: [],
-      products: [],
-      add_ons: [],
-      is_complete: true
-    };
-  }
-  const rawProducts = Array.isArray(payload.products) ? payload.products : Array.isArray(payload.items) ? payload.items : [];
-  const rawCategories = Array.isArray(payload.categories) ? payload.categories : [];
-  const rawAddOns = Array.isArray(payload.add_ons) ? payload.add_ons : [];
-  return {
-    categories: rawCategories,
-    products: rawProducts.map((product) => normalizeCatalogueProductPayload(product)),
-    add_ons: rawAddOns.map((addOn) => normalizeAddOnPayload(addOn)),
-    is_complete: typeof payload.is_complete === "boolean" ? payload.is_complete : true,
-    total_available: toFiniteNumber(payload.total_available),
-    pagination: normalizePagination(payload.pagination)
-  };
-}
-var CatalogueQueries = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getCatalogue(opts) {
-    const result = await safe(
-      this.client.get("/api/v1/catalogue", opts)
-    );
-    if (!result.ok) return result;
-    return ok(normalizeCatalogueSnapshot(result.value));
-  }
-  async getProducts(options, opts) {
-    const path = withQuery("/api/v1/catalogue/products", {
-      category_id: options?.category,
-      taxonomy_id: options?.taxonomy,
-      search: options?.search,
-      page: options?.page,
-      tags: options?.tags?.join(","),
-      featured: options?.featured,
-      in_stock: options?.in_stock,
-      min_price: options?.min_price,
-      max_price: options?.max_price,
-      sort_by: options?.sort_by,
-      sort_order: options?.sort_order,
-      limit: options?.limit,
-      offset: options?.offset,
-      cursor: options?.cursor,
-      properties: options?.properties ? JSON.stringify(options.properties) : void 0
-    });
-    const result = await safe(this.client.get(path, opts));
-    if (!result.ok) return result;
-    return ok(normalizeCatalogueResult(result.value));
-  }
-  async getProduct(id, opts) {
-    const encodedId = encodeURIComponent(id);
-    const result = await safe(
-      this.client.get(`/api/v1/catalogue/products/${encodedId}`, opts)
-    );
-    if (!result.ok) return result;
-    const payload = result.value;
-    const rawProduct = isRecord(payload.item) ? payload.item : payload;
-    const product = normalizeCatalogueProductPayload(rawProduct);
-    if (isRecord(payload.category)) {
-      product.category = payload.category;
-    }
-    const addOnIds = rawProduct.add_on_ids;
-    if (Array.isArray(addOnIds) && addOnIds.length > 0) {
-      const addOnsResult = await this.getAddOns(product.id, opts);
-      if (addOnsResult.ok) {
-        product.add_ons = addOnsResult.value;
-      }
-    }
-    return ok(product);
-  }
-  async getProductBySlug(slug, opts) {
-    return this.getProduct(slug, opts);
-  }
-  async getVariants(productId) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(
-      this.client.get(`/api/v1/catalogue/products/${encodedId}/variants`)
-    );
-  }
-  async getVariantAxes(productId) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(
-      this.client.get(`/api/v1/catalogue/products/${encodedId}/variant-axes`)
-    );
-  }
-  async getVariantByAxisSelections(productId, selections) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(
-      this.client.post(
-        `/api/v1/catalogue/products/${encodedId}/variants/find`,
-        { axis_selections: selections }
-      )
-    );
-  }
-  async getVariantById(productId, variantId) {
-    const encodedProductId = encodeURIComponent(productId);
-    const encodedVariantId = encodeURIComponent(variantId);
-    return safe(
-      this.client.get(
-        `/api/v1/catalogue/products/${encodedProductId}/variants/${encodedVariantId}`
-      )
-    );
-  }
-  async getAddOns(productId, opts) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/add-ons`, opts));
-  }
-  async getCategories(opts) {
-    return safe(this.client.get("/api/v1/catalogue/categories", opts));
-  }
-  async getCategory(id, opts) {
-    const encodedId = encodeURIComponent(id);
-    return safe(this.client.get(`/api/v1/catalogue/categories/${encodedId}`, opts));
-  }
-  async getCategoryBySlug(slug, opts) {
-    return this.getCategory(slug, opts);
-  }
-  async getCategoryProducts(categoryId, options, opts) {
-    const encodedId = encodeURIComponent(categoryId);
-    const path = withQuery(`/api/v1/catalogue/categories/${encodedId}/products`, {
-      limit: options?.limit,
-      offset: options?.offset
-    });
-    return safe(this.client.get(path, opts));
-  }
-  async getCollections(opts) {
-    return safe(this.client.get("/api/v1/catalogue/collections", opts));
-  }
-  async getCollection(id, opts) {
-    const encodedId = encodeURIComponent(id);
-    return safe(this.client.get(`/api/v1/catalogue/collections/${encodedId}`, opts));
-  }
-  async getCollectionBySlug(slug, opts) {
-    return this.getCollection(slug, opts);
-  }
-  async getCollectionProducts(collectionId, options, opts) {
-    const encodedId = encodeURIComponent(collectionId);
-    const path = withQuery(`/api/v1/catalogue/collections/${encodedId}/products`, {
-      limit: options?.limit,
-      offset: options?.offset
-    });
-    return safe(this.client.get(path, opts));
-  }
-  async searchCollections(query, limit = 20) {
-    const path = withQuery("/api/v1/catalogue/collections", { search: query, limit });
-    return safe(this.client.get(path));
-  }
-  async getBundles() {
-    return safe(this.client.get("/api/v1/catalogue/bundles"));
-  }
-  async getBundle(id) {
-    const encodedId = encodeURIComponent(id);
-    return safe(this.client.get(`/api/v1/catalogue/bundles/${encodedId}`));
-  }
-  async getBundleBySlug(slug) {
-    return this.getBundle(slug);
-  }
-  async searchBundles(query, limit = 20) {
-    const path = withQuery("/api/v1/catalogue/bundles", { search: query, limit });
-    return safe(this.client.get(path));
-  }
-  async getComposites(options) {
-    const path = withQuery("/api/v1/catalogue/composites", { limit: options?.limit });
-    return safe(this.client.get(path));
-  }
-  async getComposite(id) {
-    const encodedId = encodeURIComponent(id);
-    return safe(this.client.get(`/api/v1/catalogue/composites/${encodedId}`));
-  }
-  async getCompositeByProduct(productId) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(this.client.get(`/api/v1/catalogue/composites/by-product/${encodedId}`));
-  }
-  async calculateCompositePrice(compositeId, selections, locationId) {
-    const encodedId = encodeURIComponent(compositeId);
-    return safe(
-      this.client.post(
-        `/api/v1/catalogue/composites/${encodedId}/calculate-price`,
-        {
-          selections,
-          location_id: locationId
-        }
-      )
-    );
-  }
-  async fetchQuote(input, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.post("/api/v1/catalogue/quotes", input, { idempotencyKey })
-    );
-  }
-  async getQuote(quoteId) {
-    const encodedQuoteId = encodeURIComponent(quoteId);
-    return safe(this.client.get(`/api/v1/catalogue/quotes/${encodedQuoteId}`));
-  }
-  async refreshQuote(input) {
-    const encodedQuoteId = encodeURIComponent(input.quote_id);
-    return safe(
-      this.client.post(
-        `/api/v1/catalogue/quotes/${encodedQuoteId}/refresh`,
-        input
-      )
-    );
-  }
-  async getTaxonomies(parentId) {
-    const path = withQuery("/api/v1/catalogue/taxonomies", { parent_id: parentId });
-    return safe(this.client.get(path));
-  }
-  async getTaxonomy(id) {
-    const encodedId = encodeURIComponent(id);
-    return safe(this.client.get(`/api/v1/catalogue/taxonomies/${encodedId}`));
-  }
-  async getTaxonomyPath(id) {
-    const encodedId = encodeURIComponent(id);
-    return safe(
-      this.client.get(`/api/v1/catalogue/taxonomies/${encodedId}/path`)
-    );
-  }
-  async searchTaxonomies(query, limit) {
-    const path = withQuery("/api/v1/catalogue/taxonomies/search", { q: query, limit });
-    return safe(this.client.get(path));
-  }
-  async getEligibleBillingPlans(productId, query) {
-    const encodedId = encodeURIComponent(productId);
-    const path = withQuery(`/api/v1/catalogue/products/${encodedId}/billing-plans/eligible`, {
-      customer_id: query?.customer_id,
-      quantity: query?.quantity,
-      order_value: query?.order_value
-    });
-    return safe(this.client.get(path));
-  }
-  async getProductSchedules(productId) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(
-      this.client.get(`/api/v1/catalogue/products/${encodedId}/schedules`)
-    );
-  }
-  async checkProductAvailableNow(productId, locationId) {
-    const encodedId = encodeURIComponent(productId);
-    const path = withQuery(`/api/v1/catalogue/products/${encodedId}/available-now`, {
-      location_id: locationId
-    });
-    return safe(this.client.get(path));
-  }
-  async getDeals(locationId) {
-    const path = withQuery("/api/v1/catalogue/deals", { location_id: locationId });
-    return safe(this.client.get(path));
-  }
-  async getProductsOnSale() {
-    return safe(this.client.get("/api/v1/catalogue/deals/on-sale"));
-  }
-  async getProductDeals(productId) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(this.client.get(`/api/v1/catalogue/products/${encodedId}/deals`));
-  }
-  async getCategoryDeals(categoryId) {
-    const encodedId = encodeURIComponent(categoryId);
-    return safe(this.client.get(`/api/v1/catalogue/categories/${encodedId}/deals`));
-  }
-  async getCollectionDeals(collectionId) {
-    const encodedId = encodeURIComponent(collectionId);
-    return safe(this.client.get(`/api/v1/catalogue/collections/${encodedId}/deals`));
-  }
-  async validateDiscountCode(code, orderSubtotal, locationId) {
-    return safe(
-      this.client.post("/api/v1/catalogue/deals/validate", {
-        discount_code: code,
-        order_subtotal: orderSubtotal,
-        location_id: locationId
-      })
-    );
-  }
-  async search(query, options, opts) {
-    const result = await this.getProducts(
-      {
-        ...options,
-        search: query,
-        limit: options?.limit ?? 20
-      },
-      opts
-    );
-    if (!result.ok) return result;
-    return ok(result.value.items);
-  }
-  async searchProducts(query, options, opts) {
-    return this.search(query, options, opts);
-  }
-  async getMenu(options) {
-    const path = withQuery("/api/v1/catalogue/menu", {
-      category_id: options?.category,
-      limit: options?.limit
-    });
-    return safe(this.client.get(path));
-  }
-  async getMenuCategory(categoryId) {
-    const encodedId = encodeURIComponent(categoryId);
-    return safe(this.client.get(`/api/v1/catalogue/menu/categories/${encodedId}`));
-  }
-  async getMenuItem(itemId) {
-    const encodedId = encodeURIComponent(itemId);
-    return safe(this.client.get(`/api/v1/catalogue/menu/items/${encodedId}`));
-  }
-  async getTags(options) {
-    const path = withQuery("/api/v1/catalogue/tags", {
-      tag_group: options?.tag_group,
-      search: options?.search,
-      min_usage: options?.min_usage,
-      limit: options?.limit,
-      offset: options?.offset
-    });
-    return safe(this.client.get(path));
-  }
-  async getAttributeDefinitions(namespace) {
-    const params = namespace ? `?namespace=${encodeURIComponent(namespace)}` : "";
-    return safe(
-      this.client.get(`/api/v1/catalogue/attributes${params}`)
-    );
-  }
-  async getProductAttributes(productId) {
-    const encodedId = encodeURIComponent(productId);
-    return safe(
-      this.client.get(`/api/v1/catalogue/products/${encodedId}/attributes`)
-    );
-  }
-  async getCategoryAttributes(categoryId) {
-    const encodedId = encodeURIComponent(categoryId);
-    return safe(
-      this.client.get(
-        `/api/v1/catalogue/categories/${encodedId}/attributes`
-      )
-    );
-  }
-  async getCollectionAttributes(collectionId) {
-    const encodedId = encodeURIComponent(collectionId);
-    return safe(
-      this.client.get(
-        `/api/v1/catalogue/collections/${encodedId}/attributes`
-      )
-    );
-  }
-  async getPropertyFacets(options) {
-    const path = withQuery("/api/v1/catalogue/properties/facets", {
-      category_id: options?.category_id,
-      product_type: options?.product_type
-    });
-    return safe(this.client.get(path));
-  }
-  async getTaxonomyAttributes(taxonomyId) {
-    const encodedId = encodeURIComponent(taxonomyId);
-    return safe(
-      this.client.get(
-        `/api/v1/catalogue/taxonomies/${encodedId}/attributes`
-      )
-    );
-  }
-  async searchKnowledge(query, limit) {
-    const path = withQuery("/api/v1/catalogue/knowledge-base/search", {
-      q: query,
-      limit: limit ?? 5
-    });
-    return safe(this.client.get(path));
-  }
-  async getKnowledgeArticles() {
-    return safe(this.client.get("/api/v1/catalogue/knowledge-base/articles"));
-  }
-};
-
-// src/cart.ts
-function lineItemToCartInput(item) {
-  const config = item.configuration;
-  const input = {
-    item_id: item.product_id,
-    quantity: item.quantity
-  };
-  if (config.variant) {
-    input.variant_id = config.variant.variant_id;
-  }
-  if (config.add_ons && config.add_ons.selected_options.length > 0) {
-    input.add_on_options = config.add_ons.selected_options.map((o) => o.option_id);
-  }
-  if (config.type === "bundle") {
-    input.bundle_selections = config.input;
-  } else if (config.type === "composite") {
-    input.composite_selections = config.input;
-  }
-  return input;
-}
-var CartOperations = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async get() {
-    return safe(this.client.get("/api/v1/cart"));
-  }
-  async getItems() {
-    return safe(this.client.get("/api/v1/cart/items"));
-  }
-  async getCount() {
-    return safe(this.client.get("/api/v1/cart/count"));
-  }
-  async getTotal() {
-    return safe(this.client.get("/api/v1/cart/total"));
-  }
-  async quoteDestination(input) {
-    return safe(this.client.post("/api/v1/cart/destination-quote", input));
-  }
-  async getSummary() {
-    const cartResult = await this.get();
-    if (!cartResult.ok) return cartResult;
-    const cart = cartResult.value;
-    return ok({
-      item_count: cart.items.length,
-      total_items: cart.items.reduce((sum, item) => sum + item.quantity, 0),
-      subtotal: cart.pricing.subtotal,
-      discount_amount: cart.pricing.total_discounts,
-      tax_amount: cart.pricing.tax_amount,
-      total: cart.pricing.total_price,
-      currency: cart.pricing.currency
-    });
-  }
-  async addItem(input, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.post("/api/v1/cart/items", input, { idempotencyKey })
-    );
-  }
-  async updateItem(cartItemId, updates) {
-    if (typeof updates.quantity !== "number") {
-      return {
-        ok: false,
-        error: new chunkANT574FD_js.CimplifyError(
-          "VALIDATION_ERROR",
-          "updateItem requires a quantity; richer mid-cart edits are not supported"
-        )
-      };
-    }
-    return this.updateQuantity(cartItemId, updates.quantity);
-  }
-  async updateQuantity(cartItemId, quantity) {
-    const encodedId = encodeURIComponent(cartItemId);
-    return safe(
-      this.client.patch(`/api/v1/cart/items/${encodedId}`, {
-        quantity
-      })
-    );
-  }
-  async removeItem(cartItemId) {
-    const encodedId = encodeURIComponent(cartItemId);
-    return safe(this.client.delete(`/api/v1/cart/items/${encodedId}`));
-  }
-  async clear() {
-    return safe(this.client.delete("/api/v1/cart"));
-  }
-  async applyCoupon(code, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.post(
-        "/api/v1/cart/coupons",
-        { coupon_code: code },
-        { idempotencyKey }
-      )
-    );
-  }
-  async removeCoupon() {
-    return safe(this.client.delete("/api/v1/cart/coupons/current"));
-  }
-  async reorderFromOrder(orderId) {
-    const orderResult = await this.client.orders.get(orderId);
-    if (!orderResult.ok) return orderResult;
-    const order = orderResult.value;
-    if (!order.items || order.items.length === 0) {
-      return ok({ added: [], failed: [] });
-    }
-    const added = [];
-    const failed = [];
-    for (const item of order.items) {
-      const input = lineItemToCartInput(item);
-      const result = await this.addItem(input);
-      if (result.ok) {
-        added.push({ item_id: input.item_id });
-      } else {
-        failed.push({ item_id: input.item_id, error: result.error });
-      }
-    }
-    return ok({ added, failed });
-  }
-  async isEmpty() {
-    const countResult = await this.getCount();
-    if (!countResult.ok) return countResult;
-    return ok(countResult.value === 0);
-  }
-  async hasItem(productId, variantId) {
-    const itemsResult = await this.getItems();
-    if (!itemsResult.ok) return itemsResult;
-    const found = itemsResult.value.some((item) => {
-      const matchesProduct = item.item_id === productId;
-      if (!variantId) return matchesProduct;
-      const config = item.configuration;
-      if ("variant" in config && config.variant) {
-        return matchesProduct && config.variant.variant_id === variantId;
-      }
-      return matchesProduct;
-    });
-    return ok(found);
-  }
-  async findItem(productId, variantId) {
-    const itemsResult = await this.getItems();
-    if (!itemsResult.ok) return itemsResult;
-    const found = itemsResult.value.find((item) => {
-      const matchesProduct = item.item_id === productId;
-      if (!variantId) return matchesProduct;
-      const config = item.configuration;
-      if ("variant" in config && config.variant) {
-        return matchesProduct && config.variant.variant_id === variantId;
-      }
-      return matchesProduct;
-    });
-    return ok(found);
-  }
-};
-
-// src/payment-authorization/types.ts
-var PAYMENT_AUTHORIZATION_OUTCOME_STATUS = {
-  SUBMITTED: "submitted",
-  CANCELLED: "cancelled",
-  FAILED: "failed"
-};
-var PAYMENT_AUTHORIZATION_PROVIDER = {
-  PAYSTACK: "paystack",
-  STRIPE: "stripe"
-};
-
-// src/payment-authorization/providers/paystack.ts
-var PAYSTACK_POPUP_ERROR = {
-  PROVIDER_UNAVAILABLE: chunkANT574FD_js.ErrorCode.PROVIDER_UNAVAILABLE,
-  SUBMISSION_UNKNOWN: "SUBMISSION_UNKNOWN",
-  CANCELLED: "CANCELLED",
-  PAYMENT_CANCELLED: chunkANT574FD_js.ErrorCode.PAYMENT_CANCELLED,
-  PAYMENT_FAILED: chunkANT574FD_js.ErrorCode.PAYMENT_FAILED,
-  POPUP_BLOCKED: chunkANT574FD_js.ErrorCode.POPUP_BLOCKED
-};
-async function openPaystackPopup(options, signal) {
-  if (typeof window === "undefined") {
-    return { success: false, error: PAYSTACK_POPUP_ERROR.PROVIDER_UNAVAILABLE };
-  }
-  let PaystackPop;
-  try {
-    const imported = await import('@paystack/inline-js');
-    PaystackPop = imported.default;
-  } catch {
-    return { success: false, error: PAYSTACK_POPUP_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 ? PAYSTACK_POPUP_ERROR.SUBMISSION_UNKNOWN : PAYSTACK_POPUP_ERROR.CANCELLED
-      });
-    };
-    if (signal?.aborted) {
-      resolveOnce({ success: false, error: PAYSTACK_POPUP_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: PAYSTACK_POPUP_ERROR.PAYMENT_CANCELLED });
-        },
-        onError: (error) => {
-          resolveOnce({
-            success: false,
-            error: error?.message || PAYSTACK_POPUP_ERROR.PAYMENT_FAILED
-          });
-        }
-      });
-      providerStarted = true;
-    } catch {
-      resolveOnce({ success: false, error: PAYSTACK_POPUP_ERROR.POPUP_BLOCKED });
-    }
-  });
-}
-var PaystackAuthorizationAdapter = class {
-  constructor(openPopup = openPaystackPopup) {
-    this.openPopup = openPopup;
-    this.provider = PAYMENT_AUTHORIZATION_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: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
-        reference: result.reference || context.reference
-      };
-    }
-    if (result.error === PAYSTACK_POPUP_ERROR.SUBMISSION_UNKNOWN) {
-      return {
-        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
-        reference: context.reference
-      };
-    }
-    if (!result.error || result.error === PAYSTACK_POPUP_ERROR.CANCELLED || result.error === PAYSTACK_POPUP_ERROR.PAYMENT_CANCELLED) {
-      return { status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED };
-    }
-    if (result.error === PAYSTACK_POPUP_ERROR.POPUP_BLOCKED) {
-      return {
-        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-        code: chunkANT574FD_js.ErrorCode.POPUP_BLOCKED,
-        message: "Unable to open the Paystack payment popup. Please allow popups and try again.",
-        recoverable: true
-      };
-    }
-    if (result.error === PAYSTACK_POPUP_ERROR.PROVIDER_UNAVAILABLE) {
-      return {
-        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-        code: chunkANT574FD_js.ErrorCode.PROVIDER_UNAVAILABLE,
-        message: "Paystack is unavailable in this environment.",
-        recoverable: false
-      };
-    }
-    return {
-      status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-      code: chunkANT574FD_js.ErrorCode.PAYMENT_FAILED,
-      message: result.error || "Paystack payment could not be submitted.",
-      recoverable: true
-    };
-  }
-};
-
-// src/payment-authorization/providers/stripe.ts
-var STRIPE_REDIRECT_MODE = "if_required";
-var STRIPE_PAYMENT_ELEMENT_TYPE = "payment";
-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: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-      code: chunkANT574FD_js.ErrorCode.AUTHORIZATION_FAILED,
-      message,
-      recoverable: true
-    };
-  }
-  return {
-    status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-    code: chunkANT574FD_js.ErrorCode.PAYMENT_FAILED,
-    message,
-    recoverable: true
-  };
-}
-var StripeAuthorizationAdapter = class {
-  constructor(loadStripe = loadStripeFromPeer) {
-    this.loadStripe = loadStripe;
-    this.provider = PAYMENT_AUTHORIZATION_PROVIDER.STRIPE;
-  }
-  async authorize(context) {
-    if (typeof window === "undefined" || typeof document === "undefined" || context.signal?.aborted) {
-      return context.signal?.aborted ? { status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED } : {
-        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-        code: chunkANT574FD_js.ErrorCode.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: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-        code: chunkANT574FD_js.ErrorCode.PROVIDER_UNAVAILABLE,
-        message: error instanceof Error ? error.message : "Stripe.js could not be loaded.",
-        recoverable: true
-      };
-    }
-    if (context.signal?.aborted) {
-      return { status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED };
-    }
-    if (!stripe) {
-      return {
-        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-        code: chunkANT574FD_js.ErrorCode.PROVIDER_UNAVAILABLE,
-        message: "Stripe.js could not be loaded.",
-        recoverable: false
-      };
-    }
-    const modal = createStripeModal();
-    if (!modal) {
-      return {
-        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-        code: chunkANT574FD_js.ErrorCode.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(STRIPE_PAYMENT_ELEMENT_TYPE);
-      paymentElement.mount(modal.paymentMount);
-    } catch {
-      modal.root.remove();
-      modal.previousFocus?.focus();
-      return {
-        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-        code: chunkANT574FD_js.ErrorCode.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: PAYMENT_AUTHORIZATION_OUTCOME_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: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
-            reference: context.reference
-          });
-          return;
-        }
-        settle({ status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED });
-      };
-      const onCancel = () => {
-        if (!confirmationStarted) {
-          settle({ status: PAYMENT_AUTHORIZATION_OUTCOME_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: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED });
-            return;
-          }
-          confirmationStarted = true;
-          modal.cancelButton.disabled = true;
-          const confirmation = await stripe.confirmPayment({
-            elements,
-            confirmParams: { return_url: context.returnUrl || window.location.href },
-            redirect: STRIPE_REDIRECT_MODE
-          });
-          if (settled) return;
-          if (confirmation.error) {
-            settle(stripeFailure(confirmation.error));
-            return;
-          }
-          settle({
-            status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED,
-            reference: confirmation.paymentIntent?.id || context.reference
-          });
-        } catch (error) {
-          if (confirmationStarted) {
-            settle({
-              status: PAYMENT_AUTHORIZATION_OUTCOME_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: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-          code: chunkANT574FD_js.ErrorCode.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: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-        code: chunkANT574FD_js.ErrorCode.PROVIDER_UNAVAILABLE,
-        message: "Card authorization response did not identify a payment provider.",
-        recoverable: false
-      };
-    }
-    const adapter = this.adapters.get(provider);
-    if (!adapter) {
-      return {
-        status: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-        code: chunkANT574FD_js.ErrorCode.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: PAYMENT_AUTHORIZATION_OUTCOME_STATUS.FAILED,
-        code: chunkANT574FD_js.ErrorCode.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/utils/purchase-intent-confirmation.ts
-var EXACT_ZERO_MONEY = /^[+-]?0+(?:\.0+)?(?:[eE][+-]?\d+)?$/;
-function isExactlyZeroMoney(value) {
-  if (typeof value === "number") return Object.is(value, 0) || Object.is(value, -0);
-  return EXACT_ZERO_MONEY.test(value.trim());
-}
-function selectPurchaseIntentPaymentOption(terms, selection) {
-  return terms.payment_options.filter((option) => option.status === chunkANT574FD_js.PAYMENT_OPTION_STATUS.ELIGIBLE).sort((left, right) => left.rank - right.rank).find(
-    (option) => option.method_kind === selection.method_kind && (selection.payment_option_id === void 0 || option.id === selection.payment_option_id)
-  );
-}
-function createPurchaseIntentConfirmation(terms, paymentOption, idempotencyKey) {
-  const normalizedKey = idempotencyKey.trim();
-  if (!normalizedKey) throw new TypeError("idempotencyKey must not be empty");
-  const requiresOption = purchaseIntentRequiresPaymentOption(terms);
-  if (!paymentOption && requiresOption) {
-    throw new TypeError("Nonzero rail terms require an eligible payment option");
-  }
-  if (paymentOption && !requiresOption) {
-    throw new TypeError("Zero-rail terms must not name a payment option");
-  }
-  const authoritativeOption = paymentOption ? terms.payment_options.find(
-    (candidate) => candidate.id === paymentOption.id && candidate.status === chunkANT574FD_js.PAYMENT_OPTION_STATUS.ELIGIBLE
-  ) : void 0;
-  if (paymentOption && !authoritativeOption) {
-    throw new TypeError("Payment option is not eligible for these checkout terms");
-  }
-  return {
-    accepted_intent_revision: terms.intent_revision,
-    accepted_terms_version: terms.terms_version,
-    accepted_due_now: terms.money.due_now,
-    // Rail fees and routes may differ by option. Consent is to the exact
-    // server-issued buyer debit, never an ambiguous principal/fee aggregate.
-    accepted_customer_debit_amount: authoritativeOption?.customer_debit_amount ?? terms.money.rail_amount,
-    currency: terms.money.currency,
-    payment_option_id: authoritativeOption?.id ?? null,
-    idempotency_key: normalizedKey
-  };
-}
-function purchaseIntentRequiresPaymentOption(terms) {
-  return terms.payment_options.length > 0 || !isExactlyZeroMoney(terms.money.rail_amount);
-}
-var PLAIN_DECIMAL = /^([+-]?)(\d+)(?:\.(\d+))?$/;
-function canonicalDecimal(value) {
-  const match = PLAIN_DECIMAL.exec(typeof value === "number" ? String(value) : value.trim());
-  if (!match) return null;
-  const whole = match[2].replace(/^0+(?=\d)/, "");
-  const fraction = (match[3] ?? "").replace(/0+$/, "");
-  const isZero = whole === "0" && fraction === "";
-  return `${match[1] === "-" && !isZero ? "-" : ""}${whole}${fraction ? `.${fraction}` : ""}`;
-}
-function isSameAmount(left, right) {
-  const canonicalLeft = canonicalDecimal(left);
-  return canonicalLeft !== null && canonicalLeft === canonicalDecimal(right);
-}
-function confirmationForUnchangedReplacement(response, selection, idempotencyKey) {
-  const { replacement, deltas } = response;
-  const paymentDeltas = deltas.filter(
-    (delta2) => delta2.kind === chunkANT574FD_js.CHECKOUT_TERMS_DELTA_KIND.PAYMENT_OPTION
-  );
-  if (paymentDeltas.length !== deltas.length) return null;
-  if (!purchaseIntentRequiresPaymentOption(replacement)) {
-    return paymentDeltas.length === 0 ? createPurchaseIntentConfirmation(replacement, null, idempotencyKey) : null;
-  }
-  if (!selection || paymentDeltas.length !== 1) return null;
-  const option = selectPurchaseIntentPaymentOption(replacement, {
-    method_kind: selection.method_kind
-  });
-  const [delta] = paymentDeltas;
-  if (!option || delta.kind !== chunkANT574FD_js.CHECKOUT_TERMS_DELTA_KIND.PAYMENT_OPTION) return null;
-  if (!isSameAmount(option.customer_debit_amount, delta.accepted_customer_debit_amount)) {
-    return null;
-  }
-  return createPurchaseIntentConfirmation(replacement, option, idempotencyKey);
-}
-
-// src/utils/purchase-intent-adapter.ts
-function tenderPreference(form) {
-  if (form.payment_method === chunkANT574FD_js.PURCHASE_INTENT_PAYMENT_METHOD.MOBILE_MONEY) {
-    if (form.link_payment_method_id) {
-      return {
-        method_kind: chunkANT574FD_js.PURCHASE_INTENT_PAYMENT_METHOD.MOBILE_MONEY,
-        authority: {
-          authority_kind: chunkANT574FD_js.MOBILE_MONEY_TENDER_AUTHORITY_KIND.SAVED_REFERENCE,
-          stored_instrument_id: form.link_payment_method_id
-        }
-      };
-    }
-    const details = form.mobile_money_details;
-    if (!details?.phone_number || !details.provider) {
-      throw new chunkANT574FD_js.CimplifyError(
-        chunkANT574FD_js.ErrorCode.INVALID_PAYMENT_METHOD,
-        "Mobile money requires a phone number and network.",
-        false
-      );
-    }
-    const network = chunkV32BCG7M_js.purchaseIntentMobileMoneyNetwork(details.provider);
-    if (!network) {
-      throw new chunkANT574FD_js.CimplifyError(
-        chunkANT574FD_js.ErrorCode.INVALID_PAYMENT_METHOD,
-        "That mobile money network is not available for PurchaseIntent checkout.",
-        false
-      );
-    }
-    return {
-      method_kind: chunkANT574FD_js.PURCHASE_INTENT_PAYMENT_METHOD.MOBILE_MONEY,
-      authority: {
-        authority_kind: chunkANT574FD_js.MOBILE_MONEY_TENDER_AUTHORITY_KIND.TRANSIENT,
-        phone_number: details.phone_number,
-        network
-      }
-    };
-  }
-  if (form.payment_method === chunkANT574FD_js.LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.CASH || form.payment_method === chunkANT574FD_js.PURCHASE_INTENT_PAYMENT_METHOD.OFFLINE) {
-    throw new chunkANT574FD_js.CimplifyError(
-      chunkANT574FD_js.ErrorCode.INVALID_PAYMENT_METHOD,
-      "Offline tender requires an authenticated staff checkout.",
-      false
-    );
-  }
-  if (form.payment_method === chunkANT574FD_js.PURCHASE_INTENT_PAYMENT_METHOD.CARD) {
-    return {
-      method_kind: chunkANT574FD_js.PURCHASE_INTENT_PAYMENT_METHOD.CARD,
-      stored_instrument_id: form.link_payment_method_id
-    };
-  }
-  if (form.payment_method === chunkANT574FD_js.LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.STORE_CREDIT) {
-    return void 0;
-  }
-  throw new chunkANT574FD_js.CimplifyError(
-    chunkANT574FD_js.ErrorCode.INVALID_PAYMENT_METHOD,
-    "Checkout payment method is not supported.",
-    false
-  );
-}
-function checkoutFormToIntentRequest(form, clientIntentKey) {
-  return {
-    client_intent_key: clientIntentKey,
-    source: { kind: chunkANT574FD_js.PURCHASE_INTENT_SOURCE_KIND.CART, cart_id: form.cart_id },
-    checkout: {
-      customer: form.customer,
-      order_type: form.order_type,
-      address_info: form.address_info,
-      location_id: form.location_id,
-      delivery_rate_id: form.delivery_rate_id,
-      special_instructions: form.special_instructions,
-      link_address_id: form.link_address_id,
-      metadata: form.metadata,
-      pay_currency: form.pay_currency,
-      fx_quote_id: form.fx_quote_id,
-      use_store_credit: form.use_store_credit || form.payment_method === chunkANT574FD_js.LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.STORE_CREDIT,
-      voucher_code: form.voucher_code,
-      pay_deposit: form.pay_deposit,
-      tender_preference: tenderPreference(form)
-    }
-  };
-}
-function selectCheckoutPaymentOption(terms, form) {
-  const preference = tenderPreference(form);
-  if (!preference) return void 0;
-  return terms.payment_options.filter((option) => option.status === chunkANT574FD_js.PAYMENT_OPTION_STATUS.ELIGIBLE).sort((left, right) => left.rank - right.rank).find((option) => option.method_kind === preference.method_kind);
-}
-function checkoutFormToConfirmation(_form, terms, paymentOption, idempotencyKey) {
-  return createPurchaseIntentConfirmation(terms, paymentOption, idempotencyKey);
-}
-function committedBase(response) {
-  return {
-    intent_id: response.intent_id,
-    attempt_id: response.attempt_id,
-    order_id: response.order_id,
-    order_number: response.order_number || response.order_id,
-    payment_id: response.payment_id
-  };
-}
-function confirmationToCheckoutResult(response) {
-  switch (response.status) {
-    case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.ORDER_CREATED:
-      return ok({
-        ...committedBase(response),
-        payment_status: chunkANT574FD_js.LEGACY_CHECKOUT_PAYMENT_STATUS.SUCCEEDED,
-        requires_authorization: false,
-        next_action: { type: chunkEV2EVOYS_js.CHECKOUT_NEXT_ACTION.NONE }
-      });
-    case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.COLLECTION_PROCESSING:
-      return ok({
-        ...committedBase(response),
-        payment_status: chunkANT574FD_js.LEGACY_CHECKOUT_PAYMENT_STATUS.PROCESSING,
-        requires_authorization: false,
-        next_action: { type: chunkEV2EVOYS_js.CHECKOUT_NEXT_ACTION.POLL }
-      });
-    case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_OUTCOME_UNKNOWN:
-      return ok({
-        ...committedBase(response),
-        payment_status: chunkANT574FD_js.LEGACY_CHECKOUT_PAYMENT_STATUS.UNKNOWN,
-        requires_authorization: false,
-        next_action: { type: chunkEV2EVOYS_js.CHECKOUT_NEXT_ACTION.POLL }
-      });
-    case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_FAILED:
-      return err(
-        new chunkANT574FD_js.CimplifyError(
-          chunkANT574FD_js.PURCHASE_INTENT_ERROR_CODE.PAYMENT_FAILED,
-          "Payment failed. The order remains recorded, but collection did not succeed.",
-          true
-        )
-      );
-    case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.REDIRECT_REQUIRED:
-      return ok({
-        ...committedBase(response),
-        payment_status: chunkANT574FD_js.LEGACY_CHECKOUT_PAYMENT_STATUS.REQUIRES_ACTION,
-        requires_authorization: false,
-        authorization_url: response.authorization_url,
-        next_action: {
-          type: chunkEV2EVOYS_js.CHECKOUT_NEXT_ACTION.REDIRECT,
-          authorization_url: response.authorization_url
-        }
-      });
-    case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED:
-      return ok({
-        ...committedBase(response),
-        payment_status: chunkANT574FD_js.LEGACY_CHECKOUT_PAYMENT_STATUS.REQUIRES_ACTION,
-        requires_authorization: false,
-        provider: response.provider,
-        client_secret: response.client_secret,
-        public_key: response.public_key,
-        next_action: {
-          type: chunkEV2EVOYS_js.CHECKOUT_NEXT_ACTION.CARD_POPUP,
-          provider: response.provider,
-          client_secret: response.client_secret,
-          public_key: response.public_key,
-          provider_account_id: response.provider_account_id ?? void 0
-        }
-      });
-    case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.AUTHORIZATION_REQUIRED:
-      return ok({
-        ...committedBase(response),
-        payment_status: chunkANT574FD_js.LEGACY_CHECKOUT_PAYMENT_STATUS.REQUIRES_ACTION,
-        requires_authorization: true,
-        authorization_type: response.authorization_type,
-        display_text: response.display_text,
-        next_action: {
-          type: chunkEV2EVOYS_js.CHECKOUT_NEXT_ACTION.AUTHORIZATION,
-          authorization_type: response.authorization_type,
-          display_text: response.display_text
-        }
-      });
-    case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.TERMS_CHANGED:
-      return err(
-        new chunkANT574FD_js.CimplifyError(
-          chunkANT574FD_js.PURCHASE_INTENT_ERROR_CODE.TERMS_CHANGED,
-          "Checkout terms changed. Review the replacement terms before confirming again.",
-          true
-        )
-      );
-    case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.SELECTION_UNAVAILABLE:
-      return err(
-        new chunkANT574FD_js.CimplifyError(
-          chunkANT574FD_js.PURCHASE_INTENT_ERROR_CODE.SELECTION_UNAVAILABLE,
-          "One or more checkout selections are no longer available.",
-          true
-        )
-      );
-    case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.OFFER_ENDED:
-      return err(
-        new chunkANT574FD_js.CimplifyError(
-          chunkANT574FD_js.PURCHASE_INTENT_ERROR_CODE.OFFER_ENDED,
-          "This offer has ended.",
-          false
-        )
-      );
-    case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.SOURCE_UNAVAILABLE:
-      return err(
-        new chunkANT574FD_js.CimplifyError(
-          chunkANT574FD_js.PURCHASE_INTENT_ERROR_CODE.SOURCE_UNAVAILABLE,
-          "This purchase source is unavailable.",
-          false
-        )
-      );
-  }
-}
-
-// src/checkout.ts
-function checkoutActionAuthority(response) {
-  if (response.status !== chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED && response.status !== chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.AUTHORIZATION_REQUIRED) {
-    return null;
-  }
-  const paymentId = response.payment_id?.trim();
-  return paymentId ? {
-    intentId: response.intent_id,
-    attemptId: response.attempt_id,
-    paymentId
-  } : null;
-}
-function isAmbiguousCheckoutError(error) {
-  return error.code === chunkANT574FD_js.ErrorCode.NETWORK_ERROR || error.code === chunkANT574FD_js.ErrorCode.TIMEOUT;
-}
-function authorizationKind(value) {
-  if (value && typeof value === "object" && chunkEV2EVOYS_js.AUTHORIZATION_TYPE.ADDRESS in value) {
-    return chunkEV2EVOYS_js.AUTHORIZATION_TYPE.ADDRESS;
-  }
-  if (value === chunkEV2EVOYS_js.AUTHORIZATION_TYPE.OTP || value === chunkEV2EVOYS_js.AUTHORIZATION_TYPE.PIN || value === chunkEV2EVOYS_js.AUTHORIZATION_TYPE.PHONE || value === chunkEV2EVOYS_js.AUTHORIZATION_TYPE.BIRTHDAY) {
-    return value;
-  }
-  return void 0;
-}
-function normalizeAuthorizationSubmission(expected, submission) {
-  if (submission.type !== expected) throw new Error(`Expected ${expected} authorization details.`);
-  if (submission.type === chunkEV2EVOYS_js.AUTHORIZATION_TYPE.ADDRESS) {
-    const address = submission.address.trim();
-    const city = submission.city.trim();
-    const state = submission.state.trim();
-    const zipCode = submission.zip_code.trim();
-    if (!address || !city || !state || !zipCode) {
-      throw new Error("Complete all authorization address fields.");
-    }
-    return { type: chunkEV2EVOYS_js.AUTHORIZATION_TYPE.ADDRESS, address, city, state, zip_code: zipCode };
-  }
-  const value = submission.value.trim();
-  if (!value) throw new Error("Authorization value is required.");
-  return { type: submission.type, value };
-}
-var DECIMAL_WIRE_VALUE = /^([+-]?)(\d+)(?:\.(\d+))?(?:[eE][+-]?\d+)?$/;
-function decimalSign(value) {
-  if (typeof value === "number") {
-    if (!Number.isFinite(value)) return null;
-    if (Object.is(value, 0) || Object.is(value, -0)) return 0;
-    return value > 0 ? 1 : -1;
-  }
-  const match = DECIMAL_WIRE_VALUE.exec(value.trim());
-  if (!match) return null;
-  const nonzero = [...match[2], ...match[3] ?? ""].some((digit) => digit !== "0");
-  if (!nonzero) return 0;
-  return match[1] === "-" ? -1 : 1;
-}
-function toTerminalFailure(code, message, recoverable) {
-  return {
-    success: false,
-    error: {
-      code,
-      message,
-      recoverable
-    }
-  };
-}
-function isValidCustomerName(name) {
-  const trimmed = (name ?? "").trim();
-  return trimmed.length >= 2 && /\p{L}/u.test(trimmed);
-}
-function isOfflinePaymentMethod(method) {
-  return method === chunkANT574FD_js.LEGACY_CHECKOUT_PAYMENT_METHOD_ALIAS.CASH || method === chunkANT574FD_js.PURCHASE_INTENT_PAYMENT_METHOD.OFFLINE;
-}
-function notifyCheckoutStatus(observer, status, context = {}) {
-  try {
-    observer?.(status, context);
-  } catch {
-  }
-}
-function notifyAuthorizationUi(observer, open) {
-  try {
-    observer?.(open);
-  } catch {
-  }
-}
-var MAX_STOREFRONT_COLLECTION_OPTIONS = 32;
-var CHECKOUT_INTENT_SCOPE_PREFIX = "checkout:";
-var CHECKOUT_CONFIRMATION_SCOPE_PREFIX = "checkout-confirm:";
-var CHECKOUT_INTENT_RECOVERY_FINGERPRINT = "cart-intent-v1";
-var ABORT_ERROR_NAME = "AbortError";
-var AUTHORIZATION_POPUP_NAME = "cimplify-auth";
-var AUTHORIZATION_POPUP_FEATURES = "width=520,height=760";
-var ORDER_TOKEN_QUERY_PARAMETER = "token";
-var CHECKOUT_API_ROUTE = {
-  COLLECTION_OPTIONS: "/api/v1/payments/collection-options",
-  paymentStatus: (orderId) => `/api/v1/orders/${orderId}/payment-status`,
-  updateCustomer: (orderId) => `/api/v1/orders/${orderId}/customer`,
-  verifyPayment: (orderId) => `/api/v1/orders/${orderId}/verify-payment`
-};
-var CHECKOUT_STATUS_BY_PURCHASE_INTENT_RESOLVE_STATUS = {
-  [chunkANT574FD_js.PURCHASE_INTENT_RESOLVE_STATUS.CONFIRMING]: chunkEV2EVOYS_js.CHECKOUT_STATUS.PROCESSING,
-  [chunkANT574FD_js.PURCHASE_INTENT_RESOLVE_STATUS.POLLING]: chunkEV2EVOYS_js.CHECKOUT_STATUS.POLLING,
-  [chunkANT574FD_js.PURCHASE_INTENT_RESOLVE_STATUS.AWAITING_ACTION]: chunkEV2EVOYS_js.CHECKOUT_STATUS.AWAITING_AUTHORIZATION,
-  [chunkANT574FD_js.PURCHASE_INTENT_RESOLVE_STATUS.REVIEWING_TERMS]: chunkEV2EVOYS_js.CHECKOUT_STATUS.REVIEWING_TERMS,
-  [chunkANT574FD_js.PURCHASE_INTENT_RESOLVE_STATUS.COMPLETED]: chunkEV2EVOYS_js.CHECKOUT_STATUS.FINALIZING,
-  [chunkANT574FD_js.PURCHASE_INTENT_RESOLVE_STATUS.FAILED]: chunkEV2EVOYS_js.CHECKOUT_STATUS.FAILED,
-  [chunkANT574FD_js.PURCHASE_INTENT_RESOLVE_STATUS.OUTCOME_UNKNOWN]: chunkEV2EVOYS_js.CHECKOUT_STATUS.RECOVERING
-};
-function normalizeCollectionOptions(value, expectedCurrency) {
-  if (!value || typeof value !== "object") return null;
-  const response = value;
-  if (response.presentment_currency !== expectedCurrency || !Array.isArray(response.options)) {
-    return null;
-  }
-  if (response.options.length > MAX_STOREFRONT_COLLECTION_OPTIONS) return null;
-  const options = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const candidate of response.options) {
-    if (!candidate || typeof candidate !== "object") continue;
-    const option = candidate;
-    if (option.method === chunkEV2EVOYS_js.PAYMENT_METHOD.CARD && option.network == null) {
-      if (!seen.has(chunkEV2EVOYS_js.PAYMENT_METHOD.CARD)) {
-        seen.add(chunkEV2EVOYS_js.PAYMENT_METHOD.CARD);
-        options.push({ method: chunkEV2EVOYS_js.PAYMENT_METHOD.CARD, network: null });
-      }
-      continue;
-    }
-    if (option.method !== chunkEV2EVOYS_js.PAYMENT_METHOD.MOBILE_MONEY || typeof option.network !== "string" || !option.network.trim()) {
-      continue;
-    }
-    const network = chunkV32BCG7M_js.purchaseIntentMobileMoneyNetwork(option.network);
-    if (!network) continue;
-    const key = `${chunkEV2EVOYS_js.PAYMENT_METHOD.MOBILE_MONEY}:${network}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    options.push({ method: chunkEV2EVOYS_js.PAYMENT_METHOD.MOBILE_MONEY, network });
-  }
-  return { presentment_currency: expectedCurrency, options };
-}
-var CheckoutService = class {
-  constructor(client) {
-    this.client = client;
-    /** Raw checkout material is component-lifetime only, never browser storage. */
-    this.intentCommands = /* @__PURE__ */ new Map();
-    /** Opaque owner/attempt authority for deprecated action submission. */
-    this.actionAuthorities = /* @__PURE__ */ new Map();
-  }
-  validateCheckoutData(data) {
-    if (isOfflinePaymentMethod(data.payment_method)) {
-      return new chunkANT574FD_js.CimplifyError(
-        chunkANT574FD_js.ErrorCode.INVALID_PAYMENT_METHOD,
-        "Offline payment isn't available for online checkout. Please pay by card or mobile money.",
-        false
-      );
-    }
-    if (!isValidCustomerName(data.customer?.name)) {
-      return new chunkANT574FD_js.CimplifyError(
-        chunkANT574FD_js.ErrorCode.INVALID_CUSTOMER_NAME,
-        "Enter your name, not a phone number.",
-        false
-      );
-    }
-    return null;
-  }
-  orderTokenParam(orderId) {
-    const token = this.client.getOrderToken(orderId);
-    return token ? `?${ORDER_TOKEN_QUERY_PARAMETER}=${encodeURIComponent(token)}` : "";
-  }
-  /** Available storefront collection methods for one presentment currency. */
-  async collectionOptions(currency) {
-    const normalized = currency.trim().toUpperCase();
-    if (!chunkANT574FD_js.isSupportedCurrency(normalized)) {
-      return err(
-        new chunkANT574FD_js.CimplifyError(
-          chunkANT574FD_js.ErrorCode.UNSUPPORTED_CURRENCY,
-          "No online payment method is available for this currency.",
-          false
-        )
-      );
-    }
-    const response = await safe(
-      this.client.get(
-        `${CHECKOUT_API_ROUTE.COLLECTION_OPTIONS}?currency=${encodeURIComponent(normalized)}`
-      )
-    );
-    if (!response.ok) return response;
-    const options = normalizeCollectionOptions(response.value, normalized);
-    return options ? ok(options) : err(
-      new chunkANT574FD_js.CimplifyError(
-        chunkANT574FD_js.ErrorCode.PAYMENT_CAPABILITY_MISMATCH,
-        "Payment methods could not be verified for this currency.",
-        false
-      )
-    );
-  }
-  /**
-   * Run provider-owned UI for a backend `card_popup` action. A submitted
-   * outcome is not proof of payment; callers must poll/verify with Cimplify.
-   */
-  authorizeCardPopup(action, options) {
-    return this.client.authorizationAdapters.authorize(action, options);
-  }
-  async startIntentCheckout(data, options) {
-    const invalid = this.validateCheckoutData(data);
-    if (invalid) return err(invalid);
-    const intentScope = `${CHECKOUT_INTENT_SCOPE_PREFIX}${data.cart_id}`;
-    const inMemoryCommand = JSON.stringify(data);
-    const previousCommand = this.intentCommands.get(intentScope);
-    if (previousCommand !== void 0 && previousCommand !== inMemoryCommand) {
-      clearIntentIdempotencyKey(intentScope);
-    }
-    this.intentCommands.set(intentScope, inMemoryCommand);
-    const clientIntentKey = data.idempotency_key || intentIdempotencyKey(intentScope, CHECKOUT_INTENT_RECOVERY_FINGERPRINT);
-    const checkoutData = { ...data, idempotency_key: clientIntentKey };
-    let mintRequest;
-    try {
-      mintRequest = checkoutFormToIntentRequest(checkoutData, clientIntentKey);
-    } catch (error) {
-      clearIntentIdempotencyKey(intentScope);
-      this.intentCommands.delete(intentScope);
-      return err(
-        error instanceof chunkANT574FD_js.CimplifyError ? error : new chunkANT574FD_js.CimplifyError(
-          chunkANT574FD_js.ErrorCode.CHECKOUT_VALIDATION_FAILED,
-          "Checkout details are invalid.",
-          false
-        )
-      );
-    }
-    const minted = await this.client.purchaseIntents.mint(mintRequest, options);
-    if (!minted.ok) {
-      if (!isAmbiguousCheckoutError(minted.error)) {
-        clearIntentIdempotencyKey(intentScope);
-        this.intentCommands.delete(intentScope);
-      }
-      return minted;
-    }
-    const terms = minted.value.current_terms;
-    if (!terms) {
-      clearIntentIdempotencyKey(intentScope);
-      this.intentCommands.delete(intentScope);
-      return err(
-        new chunkANT574FD_js.CimplifyError(
-          chunkANT574FD_js.ErrorCode.CHECKOUT_TERMS_UNAVAILABLE,
-          "Checkout terms are not available for this purchase intent.",
-          true
-        )
-      );
-    }
-    let paymentOption;
-    try {
-      paymentOption = selectCheckoutPaymentOption(terms, checkoutData);
-    } catch (error) {
-      return err(
-        error instanceof chunkANT574FD_js.CimplifyError ? error : new chunkANT574FD_js.CimplifyError(
-          chunkANT574FD_js.ErrorCode.INVALID_PAYMENT_METHOD,
-          "Payment details are invalid.",
-          false
-        )
-      );
-    }
-    if (!paymentOption && purchaseIntentRequiresPaymentOption(terms)) {
-      return err(
-        new chunkANT574FD_js.CimplifyError(
-          chunkANT574FD_js.ErrorCode.PAYMENT_CAPABILITY_MISMATCH,
-          "The selected payment method is not eligible for these checkout terms.",
-          true
-        )
-      );
-    }
-    const confirmationScope = `${CHECKOUT_CONFIRMATION_SCOPE_PREFIX}${minted.value.id}`;
-    const confirmationFingerprint = JSON.stringify([
-      terms.intent_revision,
-      terms.terms_version,
-      terms.terms_digest,
-      paymentOption?.id ?? null,
-      terms.money.due_now,
-      paymentOption?.customer_debit_amount ?? terms.money.rail_amount,
-      terms.money.currency
-    ]);
-    const confirmationKey = intentIdempotencyKey(
-      confirmationScope,
-      confirmationFingerprint
-    );
-    const confirmation = checkoutFormToConfirmation(
-      checkoutData,
-      terms,
-      paymentOption,
-      confirmationKey
-    );
-    const confirmed = await this.client.purchaseIntents.confirm(
-      minted.value.id,
-      confirmation,
-      options
-    );
-    if (!confirmed.ok) {
-      if (!isAmbiguousCheckoutError(confirmed.error)) {
-        clearIntentIdempotencyKey(confirmationScope);
-      }
-      return confirmed;
-    }
-    return ok({
-      intentId: minted.value.id,
-      intentScope,
-      confirmationScope,
-      confirmation,
-      initialResponse: confirmed.value,
-      terms
-    });
-  }
-  /** @deprecated Use `client.purchaseIntents.mint()` then `confirm()`. */
-  async process(data, options) {
-    const started = await this.startIntentCheckout(data, options);
-    if (!started.ok) return started;
-    this.reconcileActionAuthority(started.value.initialResponse);
-    const result = confirmationToCheckoutResult(started.value.initialResponse);
-    if (started.value.initialResponse.status === chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.ORDER_CREATED || started.value.initialResponse.status === chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.PAYMENT_FAILED) {
-      clearIntentIdempotencyKey(started.value.intentScope);
-      clearIntentIdempotencyKey(started.value.confirmationScope);
-      this.intentCommands.delete(started.value.intentScope);
-    }
-    return result;
-  }
-  async initializePayment(_orderId, _method) {
-    return err(
-      new chunkANT574FD_js.CimplifyError(
-        chunkANT574FD_js.ErrorCode.NOT_IMPLEMENTED,
-        "initializePayment is not available in REST mode.",
-        false
-      )
-    );
-  }
-  /**
-   * @deprecated Use `client.purchaseIntents.submitAction()`. This adapter works
-   * only while this CheckoutService instance retains the opaque authority
-   * returned by its own `process()` call; it never falls back to a payment-id
-   * mutation.
-   */
-  async submitAuthorization(input, options) {
-    const paymentId = input.payment_id.trim();
-    const authority = this.actionAuthorities.get(paymentId);
-    if (!authority) {
-      return err(
-        new chunkANT574FD_js.CimplifyError(
-          chunkANT574FD_js.ErrorCode.CHECKOUT_AUTHORITY_REQUIRED,
-          "The purchase-intent action authority is unavailable. Restart checkout before submitting authorization.",
-          false
-        )
-      );
-    }
-    const submitted = await this.client.purchaseIntents.submitAction(
-      authority.intentId,
-      authority.attemptId,
-      { authorization: input.authorization },
-      {
-        signal: options?.signal,
-        timeoutMs: options?.timeoutMs
-      }
-    );
-    if (!submitted.ok) return submitted;
-    this.reconcileActionAuthority(submitted.value, paymentId);
-    return confirmationToCheckoutResult(submitted.value);
-  }
-  reconcileActionAuthority(response, previousPaymentId) {
-    if (previousPaymentId) this.actionAuthorities.delete(previousPaymentId);
-    if ("payment_id" in response && typeof response.payment_id === "string" && response.payment_id.trim()) {
-      this.actionAuthorities.delete(response.payment_id.trim());
-    }
-    const authority = checkoutActionAuthority(response);
-    if (authority) this.actionAuthorities.set(authority.paymentId, authority);
-  }
-  async pollPaymentStatus(orderId, options) {
-    const encodedId = encodeURIComponent(orderId);
-    const tokenParam = this.orderTokenParam(orderId);
-    return safe(
-      this.client.get(
-        `${CHECKOUT_API_ROUTE.paymentStatus(encodedId)}${tokenParam}`,
-        options
-      )
-    );
-  }
-  async updateOrderCustomer(orderId, customer) {
-    const encodedId = encodeURIComponent(orderId);
-    const tokenParam = this.orderTokenParam(orderId);
-    return safe(
-      this.client.post(`${CHECKOUT_API_ROUTE.updateCustomer(encodedId)}${tokenParam}`, customer)
-    );
-  }
-  async verifyPayment(orderId) {
-    const encodedId = encodeURIComponent(orderId);
-    const tokenParam = this.orderTokenParam(orderId);
-    return safe(
-      this.client.post(`${CHECKOUT_API_ROUTE.verifyPayment(encodedId)}${tokenParam}`)
-    );
-  }
-  async maybeEnrollResolvedOrder(orderId, data) {
-    if (data.enroll_in_link === false) return false;
-    const business = await safe(this.client.resolveBusinessId());
-    if (!business.ok) return false;
-    const address = data.address_info.street_address ? {
-      label: "Default",
-      street_address: data.address_info.street_address,
-      apartment: data.address_info.apartment,
-      city: data.address_info.city ?? "",
-      region: data.address_info.region ?? "",
-      postal_code: data.address_info.postal_code,
-      country: data.address_info.country,
-      delivery_instructions: data.address_info.delivery_instructions,
-      phone_for_delivery: data.address_info.phone_for_delivery,
-      latitude: data.address_info.latitude,
-      longitude: data.address_info.longitude
-    } : void 0;
-    const mobileMoney = data.payment_method === chunkEV2EVOYS_js.PAYMENT_METHOD.MOBILE_MONEY && data.mobile_money_details ? {
-      phone_number: data.mobile_money_details.phone_number,
-      provider: data.mobile_money_details.provider,
-      label: "Mobile Money"
-    } : void 0;
-    try {
-      const enrollment = await this.client.link.enrollAndLinkOrder({
-        order_id: orderId,
-        business_id: business.value,
-        order_type: data.order_type,
-        address,
-        mobile_money: mobileMoney
-      });
-      return enrollment.ok && enrollment.value.success;
-    } catch {
-      return false;
-    }
-  }
-  /** @deprecated Use `client.purchaseIntents.resolve()`. */
-  async processAndResolve(data) {
-    notifyCheckoutStatus(data.on_status_change, chunkEV2EVOYS_js.CHECKOUT_STATUS.PREPARING);
-    if (!data.cart_id) {
-      return ok(
-        toTerminalFailure(
-          chunkANT574FD_js.ErrorCode.INVALID_CART,
-          "A valid cart is required before checkout can start.",
-          false
-        )
-      );
-    }
-    const cartResult = await this.client.cart.get();
-    if (!cartResult.ok || !cartResult.value?.id) {
-      return ok(
-        toTerminalFailure(
-          chunkANT574FD_js.ErrorCode.INVALID_CART,
-          "Unable to load cart for checkout.",
-          false
-        )
-      );
-    }
-    const cart = cartResult.value;
-    if (cart.id !== data.cart_id || cart.items.length === 0) {
-      return ok(
-        toTerminalFailure(
-          chunkANT574FD_js.ErrorCode.INVALID_CART,
-          "Cart is empty or no longer valid. Please refresh and try again.",
-          false
-        )
-      );
-    }
-    const checkoutData = {
-      cart_id: data.cart_id,
-      location_id: data.location_id,
-      customer: data.customer,
-      order_type: data.order_type,
-      address_info: data.address_info,
-      delivery_rate_id: data.delivery_rate_id,
-      payment_method: data.payment_method,
-      mobile_money_details: data.mobile_money_details,
-      special_instructions: data.special_instructions,
-      link_address_id: data.link_address_id,
-      link_payment_method_id: data.link_payment_method_id,
-      idempotency_key: data.idempotency_key,
-      metadata: data.metadata,
-      pay_currency: data.pay_currency,
-      fx_quote_id: data.fx_quote_id,
-      use_store_credit: data.use_store_credit,
-      voucher_code: data.voucher_code,
-      pay_deposit: data.pay_deposit
-    };
-    const rawBaseCurrency = typeof cart.pricing.currency === "string" ? cart.pricing.currency.trim().toUpperCase() : "";
-    if (!chunkANT574FD_js.isSupportedCurrency(rawBaseCurrency)) {
-      return ok(
-        toTerminalFailure(
-          chunkANT574FD_js.ErrorCode.UNSUPPORTED_CURRENCY,
-          "Cart currency is missing or unsupported. Refresh the cart before checkout.",
-          false
-        )
-      );
-    }
-    const baseCurrency = rawBaseCurrency;
-    const payCurrency = data.pay_currency?.trim().toUpperCase();
-    if (payCurrency && !chunkANT574FD_js.isSupportedCurrency(payCurrency)) {
-      return ok(
-        toTerminalFailure(
-          chunkANT574FD_js.ErrorCode.UNSUPPORTED_CURRENCY,
-          "Payment currency is unsupported for checkout.",
-          false
-        )
-      );
-    }
-    const payCurrencyCode = payCurrency && chunkANT574FD_js.isSupportedCurrency(payCurrency) ? payCurrency : void 0;
-    const cartTotalSign = decimalSign(cart.pricing.total_price);
-    if (cartTotalSign === null || cartTotalSign < 0) {
-      return ok(
-        toTerminalFailure(
-          chunkANT574FD_js.ErrorCode.CHECKOUT_VALIDATION_FAILED,
-          "Cart total is not a valid non-negative decimal amount.",
-          false
-        )
-      );
-    }
-    if (payCurrencyCode && payCurrencyCode !== baseCurrency && !checkoutData.fx_quote_id && cartTotalSign > 0) {
-      const fxQuoteResult = await this.client.fx.lockQuote({
-        from: baseCurrency,
-        to: payCurrencyCode,
-        amount: cart.pricing.total_price
-      });
-      if (!fxQuoteResult.ok) {
-        return ok(
-          toTerminalFailure(
-            chunkANT574FD_js.ErrorCode.FX_QUOTE_FAILED,
-            fxQuoteResult.error.message || "Unable to lock FX quote for checkout.",
-            true
-          )
-        );
-      }
-      checkoutData.pay_currency = payCurrencyCode;
-      checkoutData.fx_quote_id = fxQuoteResult.value.id;
-    }
-    notifyCheckoutStatus(data.on_status_change, chunkEV2EVOYS_js.CHECKOUT_STATUS.PROCESSING);
-    const started = await this.startIntentCheckout(checkoutData, { signal: data.signal });
-    if (!started.ok) {
-      return ok(
-        toTerminalFailure(
-          started.error.code || chunkANT574FD_js.ErrorCode.CHECKOUT_FAILED,
-          started.error.message || "Unable to process checkout.",
-          started.error.retryable ?? true
-        )
-      );
-    }
-    let actionFailure;
-    try {
-      const resolved = await this.client.purchaseIntents.resolve(started.value.intentId, {
-        confirmation: started.value.confirmation,
-        initialResponse: started.value.initialResponse,
-        pollIntervalMs: data.poll_interval_ms,
-        maxPollAttempts: data.max_poll_attempts,
-        signal: data.signal,
-        onStatusChange: (status, response) => {
-          const context = {};
-          if (response && "order_id" in response) context.order_id = response.order_id;
-          if (response?.status === chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.TERMS_CHANGED) {
-            context.replacement_terms = response.replacement;
-            context.terms_deltas = response.deltas;
-          }
-          if (response?.status === chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.SELECTION_UNAVAILABLE) {
-            context.unavailable_lines = response.lines;
-          }
-          const checkoutStatus = CHECKOUT_STATUS_BY_PURCHASE_INTENT_RESOLVE_STATUS[status];
-          notifyCheckoutStatus(data.on_status_change, checkoutStatus, context);
-        },
-        onActionRequired: async (action) => {
-          switch (action.status) {
-            case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.CARD_POPUP_REQUIRED: {
-              const allowPopups = data.allow_popups ?? typeof window !== "undefined";
-              if (!allowPopups) {
-                actionFailure = {
-                  code: chunkANT574FD_js.ErrorCode.PROVIDER_UNAVAILABLE,
-                  message: "Card authorization UI is unavailable in this environment.",
-                  recoverable: false
-                };
-                return chunkANT574FD_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
-              }
-              let outcome;
-              try {
-                notifyAuthorizationUi(data.on_authorization_ui_change, true);
-                outcome = await this.authorizeCardPopup(
-                  {
-                    type: chunkEV2EVOYS_js.CHECKOUT_NEXT_ACTION.CARD_POPUP,
-                    provider: action.provider,
-                    client_secret: action.client_secret,
-                    public_key: action.public_key,
-                    provider_account_id: action.provider_account_id ?? void 0
-                  },
-                  {
-                    email: checkoutData.customer.email,
-                    currency: started.value.terms.money.currency,
-                    returnUrl: data.return_url,
-                    signal: data.signal
-                  }
-                );
-              } finally {
-                notifyAuthorizationUi(data.on_authorization_ui_change, false);
-              }
-              if (outcome.status === PAYMENT_AUTHORIZATION_OUTCOME_STATUS.SUBMITTED) {
-                return chunkANT574FD_js.PURCHASE_INTENT_ACTION_DECISION.CONTINUE;
-              }
-              actionFailure = outcome.status === PAYMENT_AUTHORIZATION_OUTCOME_STATUS.CANCELLED ? {
-                code: chunkANT574FD_js.ErrorCode.PAYMENT_CANCELLED,
-                message: "Card payment was cancelled before submission.",
-                recoverable: true
-              } : {
-                code: outcome.code,
-                message: outcome.message,
-                recoverable: outcome.recoverable
-              };
-              return chunkANT574FD_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
-            }
-            case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.REDIRECT_REQUIRED: {
-              const authorizationUrl = chunkV32BCG7M_js.paymentAuthorizationUrl(action.authorization_url);
-              if (!authorizationUrl) {
-                actionFailure = {
-                  code: chunkANT574FD_js.ErrorCode.AUTHORIZATION_FAILED,
-                  message: "The provider returned an invalid authorization URL.",
-                  recoverable: false
-                };
-                return chunkANT574FD_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
-              }
-              if (typeof window !== "undefined") {
-                if (data.allow_popups === false) {
-                  window.location.assign(authorizationUrl);
-                } else {
-                  const popup = window.open(
-                    "",
-                    AUTHORIZATION_POPUP_NAME,
-                    AUTHORIZATION_POPUP_FEATURES
-                  );
-                  if (!popup) {
-                    actionFailure = {
-                      code: chunkANT574FD_js.ErrorCode.POPUP_BLOCKED,
-                      message: "Authorization popup was blocked.",
-                      recoverable: true
-                    };
-                    return chunkANT574FD_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
-                  }
-                  popup.opener = null;
-                  popup.location.replace(authorizationUrl);
-                }
-              }
-              actionFailure = {
-                code: chunkANT574FD_js.ErrorCode.REDIRECT_REQUIRED,
-                message: "Complete authorization at the payment provider, then resume checkout.",
-                recoverable: true
-              };
-              return chunkANT574FD_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
-            }
-            case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.AUTHORIZATION_REQUIRED: {
-              const expected = authorizationKind(action.authorization_type);
-              if (!expected || !data.on_authorization_required) {
-                actionFailure = {
-                  code: chunkANT574FD_js.ErrorCode.AUTHORIZATION_REQUIRED,
-                  message: "Additional payment authorization is required.",
-                  recoverable: true
-                };
-                return chunkANT574FD_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
-              }
-              let submission;
-              await data.on_authorization_required(expected, async (candidate) => {
-                if (submission) throw new Error("Authorization was already submitted.");
-                submission = normalizeAuthorizationSubmission(expected, candidate);
-              });
-              if (!submission) {
-                actionFailure = {
-                  code: chunkANT574FD_js.ErrorCode.AUTHORIZATION_REQUIRED,
-                  message: "Payment authorization was not submitted.",
-                  recoverable: true
-                };
-                return chunkANT574FD_js.PURCHASE_INTENT_ACTION_DECISION.STOP;
-              }
-              return {
-                kind: chunkANT574FD_js.PURCHASE_INTENT_ACTION_DECISION.SUBMIT,
-                request: { authorization: submission }
-              };
-            }
-          }
-        }
-      });
-      if (!resolved.ok) {
-        return ok(
-          toTerminalFailure(
-            resolved.error.code || chunkANT574FD_js.ErrorCode.CHECKOUT_FAILED,
-            resolved.error.message || "Unable to resolve checkout.",
-            resolved.error.retryable ?? true
-          )
-        );
-      }
-      switch (resolved.value.kind) {
-        case chunkANT574FD_js.PURCHASE_INTENT_RESOLUTION_KIND.COMPLETED: {
-          clearIntentIdempotencyKey(started.value.intentScope);
-          clearIntentIdempotencyKey(started.value.confirmationScope);
-          const response = resolved.value.response;
-          notifyCheckoutStatus(data.on_status_change, chunkEV2EVOYS_js.CHECKOUT_STATUS.FINALIZING, {
-            order_id: response.order_id
-          });
-          const enrolledInLink = await this.maybeEnrollResolvedOrder(response.order_id, data);
-          notifyCheckoutStatus(data.on_status_change, chunkEV2EVOYS_js.CHECKOUT_STATUS.SUCCESS, {
-            order_id: response.order_id
-          });
-          return ok({
-            success: true,
-            order: {
-              id: response.order_id,
-              order_number: response.order_number ?? response.order_id,
-              status: chunkEV2EVOYS_js.CHECKOUT_ORDER_RESULT_STATUS.CONFIRMED,
-              total: String(cart.pricing.total_price),
-              currency: started.value.terms.money.currency
-            },
-            enrolled_in_link: enrolledInLink
-          });
-        }
-        case chunkANT574FD_js.PURCHASE_INTENT_RESOLUTION_KIND.FAILED:
-          clearIntentIdempotencyKey(started.value.confirmationScope);
-          return ok(
-            toTerminalFailure(
-              chunkANT574FD_js.PURCHASE_INTENT_ERROR_CODE.PAYMENT_FAILED,
-              "Payment failed. Choose another method or retry collection.",
-              true
-            )
-          );
-        case chunkANT574FD_js.PURCHASE_INTENT_RESOLUTION_KIND.OUTCOME_UNKNOWN:
-          return ok(
-            toTerminalFailure(
-              chunkANT574FD_js.ErrorCode.PAYMENT_OUTCOME_UNKNOWN,
-              "Payment outcome is still unknown. Resume this intent before retrying.",
-              true
-            )
-          );
-        case chunkANT574FD_js.PURCHASE_INTENT_RESOLUTION_KIND.TIMED_OUT:
-          return ok(
-            toTerminalFailure(
-              chunkANT574FD_js.ErrorCode.TIMEOUT,
-              "Payment is still processing. Resume this intent to continue polling.",
-              true
-            )
-          );
-        case chunkANT574FD_js.PURCHASE_INTENT_RESOLUTION_KIND.ACTION_REQUIRED:
-          return ok(
-            toTerminalFailure(
-              actionFailure?.code ?? chunkANT574FD_js.ErrorCode.AUTHORIZATION_REQUIRED,
-              actionFailure?.message ?? "Checkout requires additional authorization.",
-              actionFailure?.recoverable ?? true
-            )
-          );
-        case chunkANT574FD_js.PURCHASE_INTENT_RESOLUTION_KIND.REVIEW_REQUIRED: {
-          const response = resolved.value.response;
-          switch (response.status) {
-            case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.TERMS_CHANGED:
-              return ok(
-                toTerminalFailure(
-                  chunkANT574FD_js.PURCHASE_INTENT_ERROR_CODE.TERMS_CHANGED,
-                  "Checkout terms changed and require explicit review.",
-                  true
-                )
-              );
-            case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.SELECTION_UNAVAILABLE:
-              return ok(
-                toTerminalFailure(
-                  chunkANT574FD_js.PURCHASE_INTENT_ERROR_CODE.SELECTION_UNAVAILABLE,
-                  "One or more checkout selections are unavailable.",
-                  true
-                )
-              );
-            case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.OFFER_ENDED:
-              return ok(
-                toTerminalFailure(
-                  chunkANT574FD_js.PURCHASE_INTENT_ERROR_CODE.OFFER_ENDED,
-                  "This offer has ended.",
-                  false
-                )
-              );
-            case chunkANT574FD_js.PURCHASE_INTENT_CONFIRM_STATUS.SOURCE_UNAVAILABLE:
-              return ok(
-                toTerminalFailure(
-                  chunkANT574FD_js.PURCHASE_INTENT_ERROR_CODE.SOURCE_UNAVAILABLE,
-                  "This purchase source is unavailable.",
-                  false
-                )
-              );
-          }
-        }
-      }
-    } catch (error) {
-      const cancelled = data.signal?.aborted || error instanceof Error && error.name === ABORT_ERROR_NAME;
-      return ok(
-        toTerminalFailure(
-          cancelled ? chunkANT574FD_js.ErrorCode.CANCELLED : chunkANT574FD_js.ErrorCode.AUTHORIZATION_FAILED,
-          cancelled ? "Checkout was cancelled." : error instanceof Error ? error.message : "Checkout authorization failed.",
-          true
-        )
-      );
-    }
-  }
-};
-
-// src/orders.ts
-var OrderQueries = class {
-  constructor(client) {
-    this.client = client;
-  }
-  orderTokenParam(orderId) {
-    const token = this.client.getOrderToken(orderId);
-    return token ? `?token=${encodeURIComponent(token)}` : "";
-  }
-  async list(options) {
-    const params = new URLSearchParams();
-    if (options?.status) params.set("status", options.status);
-    if (options?.limit) params.set("limit", String(options.limit));
-    if (options?.offset) params.set("offset", String(options.offset));
-    const path = params.toString() ? `/api/v1/orders?${params.toString()}` : "/api/v1/orders";
-    return safe(this.client.get(path));
-  }
-  async get(orderId) {
-    const encodedId = encodeURIComponent(orderId);
-    const tokenParam = this.orderTokenParam(orderId);
-    return safe(this.client.get(`/api/v1/orders/${encodedId}${tokenParam}`));
-  }
-  /**
-   * Same endpoint as `get`, typed as the enriched display contract
-   * (product names, images, resolved selections, customer inputs, scheduling,
-   * fulfillment). Feed the result through `toAccountOrderView`.
-   */
-  async getDetail(orderId) {
-    const encodedId = encodeURIComponent(orderId);
-    const tokenParam = this.orderTokenParam(orderId);
-    return safe(this.client.get(`/api/v1/orders/${encodedId}${tokenParam}`));
-  }
-  async getRecent(limit = 5) {
-    return this.list({ limit });
-  }
-  async getByStatus(status) {
-    return this.list({ status });
-  }
-  async cancel(orderId, reason, opts) {
-    const encodedId = encodeURIComponent(orderId);
-    const tokenParam = this.orderTokenParam(orderId);
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.post(
-        `/api/v1/orders/${encodedId}/cancel${tokenParam}`,
-        { reason },
-        { idempotencyKey }
-      )
-    );
-  }
-};
-
-// src/link.ts
-function encodePathSegment(value) {
-  return encodeURIComponent(value);
-}
-var LinkService = class {
-  constructor(client) {
-    this.client = client;
-    this.activationGeneration = 0;
-  }
-  beginActivation() {
-    return {
-      generation: ++this.activationGeneration,
-      sessionEpoch: this.client.getSessionEpoch(),
-      publicKeyEpoch: this.client.getPublicKeyEpoch()
-    };
-  }
-  isActivationFenceCurrent(fence) {
-    return fence.generation === this.activationGeneration && fence.sessionEpoch === this.client.getSessionEpoch() && fence.publicKeyEpoch === this.client.getPublicKeyEpoch();
-  }
-  supersededActivation() {
-    return {
-      ok: false,
-      error: new chunkANT574FD_js.CimplifyError(
-        "session_superseded",
-        "A newer authentication session replaced this one"
-      )
-    };
-  }
-  async activateAuthenticatedSession(result, fence) {
-    if (!result.ok || !result.value.session_token) return result;
-    if (!this.isActivationFenceCurrent(fence)) return this.supersededActivation();
-    const accessToken = result.value.session_token;
-    this.client.setAccessToken(accessToken);
-    const installedSessionEpoch = this.client.getSessionEpoch();
-    if (!this.client.getPublicKey().trim()) {
-      this.client.activity.refreshIdentity();
-      return result;
-    }
-    const claim = await this.client.session.claim();
-    if (fence.generation !== this.activationGeneration || fence.publicKeyEpoch !== this.client.getPublicKeyEpoch() || this.client.getAccessToken() !== accessToken) {
-      return this.supersededActivation();
-    }
-    if (!claim.ok && claim.error.code !== "already_claimed") {
-      if (this.client.getSessionEpoch() !== installedSessionEpoch) {
-        return this.supersededActivation();
-      }
-      if (this.client.hasClaimedSessionAuthority()) {
-        this.client.clearSession();
-      } else {
-        this.client.setAccessToken(null);
-      }
-      return claim;
-    }
-    this.client.activity.refreshIdentity();
-    return result;
-  }
-  async requestOtp(input, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.linkPost("/v1/link/auth/request-otp", input, {
-        idempotencyKey
-      })
-    );
-  }
-  async verifyOtp(input, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    const activationFence = opts?.activateSession === false ? null : this.beginActivation();
-    const { business_id: _ignoredBusinessId, ...body } = input;
-    const result = await safe(
-      this.client.linkPost("/v1/link/auth/verify-otp", body, { idempotencyKey })
-    );
-    return activationFence ? this.activateAuthenticatedSession(result, activationFence) : result;
-  }
-  async refreshSession(sessionToken, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    const activationFence = opts?.activateSession === false ? null : this.beginActivation();
-    const body = sessionToken ? { session_token: sessionToken } : {};
-    const result = await safe(
-      this.client.linkPost("/v1/link/auth/refresh", body, { idempotencyKey })
-    );
-    return activationFence ? this.activateAuthenticatedSession(result, activationFence) : result;
-  }
-  async logout() {
-    this.activationGeneration += 1;
-    const request = safe(this.client.linkPost("/v1/link/auth/logout"));
-    this.client.clearSession();
-    return request;
-  }
-  async checkStatus(contact) {
-    return safe(this.client.linkPost("/v1/link/check-status", { contact }));
-  }
-  async getLinkData() {
-    return safe(this.client.linkGet("/v1/link/data"));
-  }
-  async getAddresses() {
-    return safe(this.client.linkGet("/v1/link/addresses"));
-  }
-  async getMobileMoney() {
-    return safe(this.client.linkGet("/v1/link/mobile-money"));
-  }
-  async getPreferences() {
-    return safe(this.client.linkGet("/v1/link/preferences"));
-  }
-  async updateProfile(input) {
-    return safe(this.client.linkPost("/v1/link/profile", input));
-  }
-  async getOrders(options) {
-    const params = new URLSearchParams();
-    if (options?.status) params.set("status", options.status);
-    if (options?.limit) params.set("limit", String(options.limit));
-    if (options?.offset) params.set("offset", String(options.offset));
-    if (options?.businessId) params.set("business_id", options.businessId);
-    const query = params.toString();
-    const path = query ? `/v1/link/orders?${query}` : "/v1/link/orders";
-    return safe(this.client.linkGet(path));
-  }
-  async getOrder(orderId, options) {
-    const params = new URLSearchParams();
-    if (options?.businessId) params.set("business_id", options.businessId);
-    const query = params.toString();
-    const path = query ? `/v1/link/orders/${encodePathSegment(orderId)}?${query}` : `/v1/link/orders/${encodePathSegment(orderId)}`;
-    return safe(this.client.linkGet(path));
-  }
-  async enroll(data, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.linkPost("/v1/link/enroll", data, { idempotencyKey })
-    );
-  }
-  async enrollAndLinkOrder(data, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.linkPost("/v1/link/enroll-and-link-order", data, {
-        idempotencyKey
-      })
-    );
-  }
-  async updatePreferences(preferences) {
-    return safe(this.client.linkPost("/v1/link/preferences", preferences));
-  }
-  async createAddress(input, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.linkPost("/v1/link/addresses", input, { idempotencyKey })
-    );
-  }
-  async updateAddress(input) {
-    const { address_id, ...patch } = input;
-    return safe(
-      this.client.linkPost(
-        `/v1/link/addresses/${encodePathSegment(address_id)}`,
-        patch
-      )
-    );
-  }
-  async deleteAddress(addressId) {
-    return safe(
-      this.client.linkDelete(`/v1/link/addresses/${encodePathSegment(addressId)}`)
-    );
-  }
-  async setDefaultAddress(addressId) {
-    return safe(
-      this.client.linkPost(
-        `/v1/link/addresses/${encodePathSegment(addressId)}/default`
-      )
-    );
-  }
-  async trackAddressUsage(addressId) {
-    return safe(
-      this.client.linkPost(
-        `/v1/link/addresses/${encodePathSegment(addressId)}/track-usage`
-      )
-    );
-  }
-  async createMobileMoney(input, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.linkPost("/v1/link/mobile-money", input, { idempotencyKey })
-    );
-  }
-  async deleteMobileMoney(mobileMoneyId) {
-    return safe(
-      this.client.linkDelete(
-        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}`
-      )
-    );
-  }
-  async setDefaultMobileMoney(mobileMoneyId) {
-    return safe(
-      this.client.linkPost(
-        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/default`
-      )
-    );
-  }
-  async trackMobileMoneyUsage(mobileMoneyId) {
-    return safe(
-      this.client.linkPost(
-        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/track-usage`
-      )
-    );
-  }
-  async verifyMobileMoney(mobileMoneyId, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.linkPost(
-        `/v1/link/mobile-money/${encodePathSegment(mobileMoneyId)}/verify`,
-        void 0,
-        { idempotencyKey }
-      )
-    );
-  }
-  async getSessions() {
-    return safe(this.client.linkGet("/v1/link/sessions"));
-  }
-  async revokeSession(sessionId) {
-    return safe(this.client.linkDelete(`/v1/link/sessions/${sessionId}`));
-  }
-  async revokeAllSessions() {
-    return safe(this.client.linkDelete("/v1/link/sessions"));
-  }
-};
-
-// src/auth.ts
-var AuthService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getStatus() {
-    return safe(this.client.get("/api/v1/auth/status"));
-  }
-  async getCurrentUser() {
-    const result = await this.getStatus();
-    if (!result.ok) return result;
-    return ok(result.value.customer || null);
-  }
-  async isAuthenticated() {
-    const result = await this.getStatus();
-    if (!result.ok) return result;
-    return ok(result.value.is_authenticated);
-  }
-  async requestOtp(contact, contactType, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.post(
-        "/api/v1/auth/request-otp",
-        { contact, contact_type: contactType },
-        { idempotencyKey }
-      )
-    );
-  }
-  async verifyOtp(code, contact, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    const result = await safe(
-      this.client.post(
-        "/api/v1/auth/verify-otp",
-        { otp_code: code, contact },
-        { idempotencyKey }
-      )
-    );
-    if (result.ok && result.value.session_token) {
-      this.client.setAccessToken(result.value.session_token);
-      this.client.activity.refreshIdentity();
-      this.client.autoClaimSession();
-    }
-    return result;
-  }
-  async logout() {
-    const result = await safe(this.client.post("/api/v1/auth/logout"));
-    this.client.clearSession();
-    return result;
-  }
-  async updateProfile(input) {
-    return safe(this.client.post("/api/v1/auth/profile", input));
-  }
-};
-
-// src/business.ts
-var BusinessService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getInfo(opts) {
-    return safe(this.client.get("/api/v1/business", opts));
-  }
-  async getByHandle(handle, opts) {
-    const encodedHandle = encodeURIComponent(handle);
-    return safe(this.client.get(`/api/v1/business/by-handle/${encodedHandle}`, opts));
-  }
-  async getByDomain(domain, opts) {
-    const encodedDomain = encodeURIComponent(domain);
-    return safe(this.client.get(`/api/v1/business/by-domain?domain=${encodedDomain}`, opts));
-  }
-  async getSettings(opts) {
-    return safe(this.client.get("/api/v1/business/settings", opts));
-  }
-  async getLocations(opts) {
-    return safe(this.client.get("/api/v1/business/locations", opts));
-  }
-  async getLocation(locationId, opts) {
-    const result = await this.getLocations(opts);
-    if (!result.ok) return err(result.error);
-    const location = result.value.find((item) => item.id === locationId);
-    if (!location) {
-      return err(new chunkANT574FD_js.CimplifyError(chunkANT574FD_js.ErrorCode.NOT_FOUND, `Location not found: ${locationId}`, false));
-    }
-    return ok(location);
-  }
-  async getHours(opts) {
-    return safe(this.client.get("/api/v1/business/hours", opts));
-  }
-  async getLocationHours(locationId, opts) {
-    const result = await this.getHours(opts);
-    if (!result.ok) return result;
-    return ok(result.value.filter((hour) => hour.location_id === locationId));
-  }
-  async getBootstrap(opts) {
-    return safe(this.client.get("/api/v1/bootstrap", opts));
-  }
-};
-
-// src/inventory.ts
-var InventoryService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  withQuery(path, params) {
-    const searchParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-      if (value === void 0) continue;
-      searchParams.set(key, String(value));
-    }
-    const query = searchParams.toString();
-    return query ? `${path}?${query}` : path;
-  }
-  async getProductStock(productId, locationId) {
-    const encodedId = encodeURIComponent(productId);
-    const path = this.withQuery(`/api/v1/inventory/products/${encodedId}/stock`, {
-      location_id: locationId
-    });
-    return safe(this.client.get(path));
-  }
-  async getVariantStock(variantId, locationId) {
-    const encodedId = encodeURIComponent(variantId);
-    const path = this.withQuery(`/api/v1/inventory/variants/${encodedId}/stock`, {
-      location_id: locationId
-    });
-    return safe(this.client.get(path));
-  }
-  async checkProductAvailability(productId, quantity, locationId) {
-    const encodedId = encodeURIComponent(productId);
-    const path = this.withQuery(`/api/v1/inventory/products/${encodedId}/availability`, {
-      quantity,
-      location_id: locationId
-    });
-    return safe(this.client.get(path));
-  }
-  async checkVariantAvailability(variantId, quantity, locationId) {
-    const encodedId = encodeURIComponent(variantId);
-    const path = this.withQuery(`/api/v1/inventory/variants/${encodedId}/availability`, {
-      quantity,
-      location_id: locationId
-    });
-    return safe(this.client.get(path));
-  }
-  async checkMultipleAvailability(items, locationId) {
-    const results = await Promise.all(
-      items.map(
-        (item) => item.variant_id ? this.checkVariantAvailability(item.variant_id, item.quantity, locationId) : this.checkProductAvailability(item.product_id, item.quantity, locationId)
-      )
-    );
-    for (const result of results) {
-      if (!result.ok) return result;
-    }
-    return ok(results.map((r) => r.value));
-  }
-  async isInStock(productId, locationId) {
-    const result = await this.checkProductAvailability(productId, 1, locationId);
-    if (!result.ok) return result;
-    return ok(result.value.is_available);
-  }
-  async getAvailableQuantity(productId, locationId) {
-    const result = await this.getProductStock(productId, locationId);
-    if (!result.ok) return result;
-    return ok(result.value.available_quantity ?? void 0);
-  }
-};
-
-// src/scheduling.ts
-function withQuery2(path, params) {
-  const searchParams = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value === void 0) continue;
-    searchParams.set(key, String(value));
-  }
-  const query = searchParams.toString();
-  return query ? `${path}?${query}` : path;
-}
-function firstScheduledTime(booking) {
-  return booking.service_items.find((item) => typeof item.scheduled_start === "string")?.scheduled_start || booking.created_at;
-}
-var SchedulingService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getServices() {
-    return safe(this.client.get("/api/v1/scheduling/services"));
-  }
-  async getService(serviceId) {
-    const encodedId = encodeURIComponent(serviceId);
-    return safe(this.client.get(`/api/v1/scheduling/services/${encodedId}`));
-  }
-  async getAvailableSlots(input) {
-    const path = withQuery2("/api/v1/scheduling/slots", {
-      service_id: input.service_id,
-      date: input.date,
-      participant_count: input.participant_count,
-      units: input.units,
-      variant_id: input.variant_id
-    });
-    return safe(this.client.get(path));
-  }
-  async checkSlotAvailability(input) {
-    const path = withQuery2("/api/v1/scheduling/slots/check", {
-      service_id: input.service_id,
-      slot_time: input.slot_time,
-      duration_minutes: input.duration_minutes,
-      participant_count: input.participant_count
-    });
-    return safe(this.client.get(path));
-  }
-  async getServiceAvailability(params) {
-    const path = withQuery2("/api/v1/scheduling/availability", {
-      service_id: params.service_id,
-      start_date: params.start_date,
-      end_date: params.end_date,
-      location_id: params.location_id,
-      participant_count: params.participant_count,
-      units: params.units,
-      variant_id: params.variant_id
-    });
-    return safe(this.client.get(path));
-  }
-  async getBooking(bookingId) {
-    const encodedId = encodeURIComponent(bookingId);
-    return safe(this.client.get(`/api/v1/scheduling/bookings/${encodedId}`));
-  }
-  async getCustomerBookings(customerId) {
-    const path = withQuery2("/api/v1/scheduling/bookings", {
-      customer_id: customerId
-    });
-    return safe(this.client.get(path));
-  }
-  async getUpcomingBookings() {
-    const result = await this.getCustomerBookings();
-    if (!result.ok) return result;
-    const upcoming = result.value.filter((booking) => {
-      const status = String(booking.status).toLowerCase();
-      return status !== "completed" && status !== "cancelled";
-    }).sort((a, b) => firstScheduledTime(a).localeCompare(firstScheduledTime(b)));
-    return ok(upcoming);
-  }
-  async getPastBookings(limit = 10) {
-    const result = await this.getCustomerBookings();
-    if (!result.ok) return result;
-    const past = result.value.filter((booking) => String(booking.status).toLowerCase() === "completed").sort((a, b) => firstScheduledTime(b).localeCompare(firstScheduledTime(a))).slice(0, Math.max(0, limit));
-    return ok(past);
-  }
-  async cancelBooking(input, opts) {
-    const encodedId = encodeURIComponent(input.booking_id);
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.post(
-        `/api/v1/scheduling/bookings/${encodedId}/cancel`,
-        { reason: input.reason },
-        { idempotencyKey }
-      )
-    );
-  }
-  async rescheduleBooking(input, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.post(
-        "/api/v1/scheduling/bookings/reschedule",
-        input,
-        { idempotencyKey }
-      )
-    );
-  }
-  async getNextAvailableSlot(serviceId, fromDate) {
-    const date = fromDate || (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-    const result = await this.getAvailableSlots({
-      service_id: serviceId,
-      date
-    });
-    if (!result.ok) return result;
-    return ok(result.value[0] ?? null);
-  }
-  async hasAvailabilityOn(serviceId, date) {
-    const result = await this.getAvailableSlots({
-      service_id: serviceId,
-      date
-    });
-    if (!result.ok) return result;
-    return ok(result.value.length > 0);
-  }
-};
-
-// src/lite.ts
-var LiteService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getBootstrap() {
-    return safe(this.client.get("/api/v1/lite/bootstrap"));
-  }
-  async getResource(resourceId) {
-    const encodedId = encodeURIComponent(resourceId);
-    return safe(this.client.get(`/api/v1/lite/resources/${encodedId}`));
-  }
-  async getMenu() {
-    return safe(this.client.get("/api/v1/lite/menu"));
-  }
-  async getMenuByCategory(categoryId) {
-    const encodedId = encodeURIComponent(categoryId);
-    return safe(this.client.get(`/api/v1/lite/menu/categories/${encodedId}`));
-  }
-};
-
-// src/fx.ts
-var FxService = class {
-  constructor(client) {
-    this.client = client;
-  }
-  async getRate(from, to) {
-    const path = `/api/v1/fx/rate?from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`;
-    return safe(this.client.get(path));
-  }
-  async lockQuote(request, opts) {
-    const idempotencyKey = opts?.idempotencyKey ?? generateIdempotencyKey();
-    return safe(
-      this.client.post("/api/v1/fx/quotes", request, { idempotencyKey })
-    );
-  }
-};
-
-// src/types/elements.ts
-var ELEMENT_TYPES = {
-  AUTH: "auth",
-  ADDRESS: "address",
-  PAYMENT: "payment",
-  CHECKOUT: "checkout",
-  ACCOUNT: "account"
-};
-var MESSAGE_TYPES = {
-  INIT: "init",
-  IDENTITY: "identity",
-  SESSION_CLEARED: "session_cleared",
-  SET_CART: "set_cart",
-  GET_DATA: "get_data",
-  LOGOUT: "logout",
-  PROCESS_CHECKOUT: "process_checkout",
-  ABORT_CHECKOUT: "abort_checkout",
-  READY: "ready",
-  HEIGHT_CHANGE: "height_change",
-  ERROR: "error",
-  ADDRESS_CHANGED: "address_changed",
-  ADDRESS_SELECTED: "address_selected",
-  PAYMENT_METHOD_SELECTED: "payment_method_selected",
-  LOGOUT_COMPLETE: "logout_complete",
-  AUTH_REQUESTED: "auth_requested",
-  SESSION_ESTABLISHED: "session_established",
-  CONTINUE_WITHOUT_SAVED_DETAILS: "continue_without_saved_details",
-  CONTACT_PROVIDED: "contact_provided",
-  CHECKOUT_STATUS: "checkout_status",
-  CHECKOUT_COMPLETE: "checkout_complete",
-  TERMS_CHANGED: "terms_changed",
-  SELECTION_UNAVAILABLE: "selection_unavailable",
-  ORDER_TYPE_CHANGED: "order_type_changed",
-  REQUEST_SUBMIT: "request_submit"
-};
-var ELEMENTS_AUTH_CONTACT_TYPES = {
-  EMAIL: "email",
-  PHONE: "phone"
-};
-var ELEMENTS_AUTH_PROMPTS = {
-  LOGIN: "login"
-};
-var ELEMENTS_AUTH_MODES = {
-  CHECKOUT: "checkout",
-  DEFAULT: "default"
-};
-var EVENT_TYPES = {
-  READY: "ready",
-  AUTHENTICATED: "authenticated",
-  ERROR: "error",
-  CHANGE: "change",
-  BLUR: "blur",
-  FOCUS: "focus",
-  ORDER_TYPE_CHANGED: "order_type_changed",
-  REQUEST_SUBMIT: "request_submit"
-};
-
-// src/internal/pkce.ts
-var VERIFIER_BYTES = 64;
-async function generatePkce() {
-  const random = new Uint8Array(VERIFIER_BYTES);
-  crypto.getRandomValues(random);
-  const verifier = base64UrlEncode(random);
-  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
-  const challenge = base64UrlEncode(new Uint8Array(digest));
-  return { verifier, challenge, method: "S256" };
-}
-function generateState(byteLength = 16) {
-  const buf = new Uint8Array(byteLength);
-  crypto.getRandomValues(buf);
-  return base64UrlEncode(buf);
-}
-function base64UrlEncode(bytes) {
-  let str = "";
-  for (const byte of bytes) str += String.fromCharCode(byte);
-  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-
-// src/internal/pkce-cookie.ts
-var PKCE_COOKIE = "cimplify_pkce";
-var PKCE_COOKIE_PATH = "/auth";
-var PKCE_COOKIE_MAX_AGE_SECONDS = 600;
-function encodePkceState(state) {
-  return encodeURIComponent(JSON.stringify(state));
-}
-function decodePkceState(raw) {
-  try {
-    const parsed = JSON.parse(decodeURIComponent(raw));
-    if (typeof parsed?.verifier === "string" && typeof parsed.state === "string" && typeof parsed.returnTo === "string") {
-      return { verifier: parsed.verifier, state: parsed.state, returnTo: parsed.returnTo };
-    }
-  } catch {
-  }
-  return null;
-}
-
-// src/internal/discovery.ts
-var DEFAULT_ISSUER = "https://api.cimplify.io";
-var DEFAULT_AUTHORIZATION_ENDPOINT = "https://auth.cimplify.io/oauth/authorize";
-function fallbackAuthorizationEndpoint(issuerBase) {
-  if (issuerBase === DEFAULT_ISSUER) return DEFAULT_AUTHORIZATION_ENDPOINT;
-  throw new Error(
-    `OIDC discovery for "${issuerBase}" is unreachable and no fallback authorize endpoint is known for it. Make discovery reachable (enable CORS) or pass authUrl.`
-  );
-}
-var cache = /* @__PURE__ */ new Map();
-function fetchDiscovery(issuer) {
-  const base = issuer.replace(/\/$/, "");
-  let pending = cache.get(base);
-  if (!pending) {
-    pending = fetch(`${base}/.well-known/openid-configuration`).then((res) => {
-      if (!res.ok) throw new Error(`oidc discovery failed: ${res.status}`);
-      return res.json();
-    });
-    pending.catch(() => cache.delete(base));
-    cache.set(base, pending);
-  }
-  return pending;
-}
-async function getAuthorizationEndpoint(issuer) {
-  const base = issuer.replace(/\/$/, "");
-  try {
-    const doc = await fetchDiscovery(base);
-    if (doc.authorization_endpoint) return doc.authorization_endpoint;
-  } catch {
-  }
-  return fallbackAuthorizationEndpoint(base);
-}
-
-// src/internal/modal-iframe.ts
-function openModalIframe(opts) {
-  const overlay = document.createElement("div");
-  overlay.dataset.cimplifyModal = "1";
-  Object.assign(overlay.style, {
-    position: "fixed",
-    inset: "0",
-    background: "rgba(15, 18, 24, 0.55)",
-    zIndex: "2147483647",
-    display: "grid",
-    placeItems: "center",
-    backdropFilter: "blur(2px)"
-  });
-  const card = document.createElement("div");
-  Object.assign(card.style, {
-    width: `${opts.width ?? 480}px`,
-    maxWidth: "calc(100vw - 24px)",
-    height: `${opts.height ?? 720}px`,
-    maxHeight: "calc(100vh - 32px)"
-  });
-  const iframe = document.createElement("iframe");
-  iframe.src = opts.src;
-  iframe.style.width = "100%";
-  iframe.style.height = "100%";
-  iframe.style.border = "none";
-  iframe.style.background = "transparent";
-  iframe.setAttribute(
-    "sandbox",
-    opts.sandbox ?? "allow-scripts allow-same-origin allow-forms allow-popups"
-  );
-  iframe.setAttribute("allow", "publickey-credentials-get; publickey-credentials-create");
-  card.appendChild(iframe);
-  overlay.appendChild(card);
-  document.body.appendChild(overlay);
-  const close = () => {
-    overlay.remove();
-    document.removeEventListener("keydown", onKey);
-    opts.onClose?.();
-  };
-  const onKey = (e) => {
-    if (e.key === "Escape") close();
-  };
-  overlay.addEventListener("click", (e) => {
-    if (e.target === overlay) close();
-  });
-  document.addEventListener("keydown", onKey);
-  return { iframe, close };
-}
-
-// src/sign-in.ts
-var DEFAULT_SCOPE = "openid email phone profile";
-var DEFAULT_SILENT_TIMEOUT_MS = 900;
-var RESPONSE_TYPE_CODE = "code";
-var RESPONSE_MODE_WEB_MESSAGE = "web_message";
-var RESPONSE_MODE_QUERY = "query";
-var PROMPT_NONE = "none";
-var AUTHORIZATION_RESPONSE_MESSAGE_TYPE = "authorization_response";
-var ERROR_STATE_MISMATCH = "state_mismatch";
-var ERROR_CALLBACK_FAILED = "callback_failed";
-var ERROR_CALLBACK_EXCEPTION = "callback_exception";
-var ERROR_CANCELLED = "cancelled";
-var ERROR_LOGIN_REQUIRED = "login_required";
-var ERROR_CONSENT_REQUIRED = "consent_required";
-var ERROR_INTERACTION_REQUIRED = "interaction_required";
-var INTERACTIVE_AUTH_ERRORS = /* @__PURE__ */ new Set([
-  ERROR_LOGIN_REQUIRED,
-  ERROR_CONSENT_REQUIRED,
-  ERROR_INTERACTION_REQUIRED
-]);
-function buildAuthorizeUrl(opts, authorizeEndpoint, pkce, state, urlOpts) {
-  const params = new URLSearchParams({
-    response_type: RESPONSE_TYPE_CODE,
-    response_mode: urlOpts.responseMode,
-    client_id: opts.clientId,
-    redirect_uri: opts.redirectUri,
-    scope: opts.scope ?? DEFAULT_SCOPE,
-    state,
-    code_challenge: pkce.challenge,
-    code_challenge_method: pkce.method
-  });
-  if (opts.loginHint) params.set("login_hint", opts.loginHint);
-  if (urlOpts.prompt) params.set("prompt", urlOpts.prompt);
-  if (opts.uiMode) params.set("ui_mode", opts.uiMode);
-  return `${authorizeEndpoint}?${params.toString()}`;
-}
-async function exchangeAuthorizationCode(callbackUri, pkce, state, code) {
-  const res = await fetch(callbackUri, {
-    method: "POST",
-    credentials: "include",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ code, codeVerifier: pkce.verifier, state })
-  });
-  if (!res.ok) {
-    const body = await res.text().catch(() => "");
-    throw { error: ERROR_CALLBACK_FAILED, description: body };
-  }
-  const payload = await res.json().catch(() => ({}));
-  return {
-    accessToken: payload.accessToken ?? payload.access_token,
-    expiresIn: payload.expiresIn ?? payload.expires_in,
-    scope: payload.scope
-  };
-}
-async function trySilentModalSignIn(opts, authorizeEndpoint, callbackUri, pkce, state) {
-  const expectedOrigin = new URL(authorizeEndpoint).origin;
-  const iframe = document.createElement("iframe");
-  iframe.style.display = "none";
-  iframe.setAttribute("aria-hidden", "true");
-  iframe.setAttribute("sandbox", "allow-scripts allow-same-origin");
-  iframe.src = buildAuthorizeUrl(opts, authorizeEndpoint, pkce, state, {
-    responseMode: RESPONSE_MODE_WEB_MESSAGE,
-    prompt: PROMPT_NONE
-  });
-  return new Promise((resolve) => {
-    let settled = false;
-    let handler = () => {
-    };
-    const timeout = setTimeout(() => finish(false), opts.silentTimeoutMs ?? DEFAULT_SILENT_TIMEOUT_MS);
-    const cleanup = () => {
-      window.removeEventListener("message", handler);
-      iframe.remove();
-      clearTimeout(timeout);
-    };
-    const finish = (handled) => {
-      if (settled) return;
-      settled = true;
-      cleanup();
-      resolve(handled);
-    };
-    handler = async (event) => {
-      if (event.origin !== expectedOrigin) return;
-      const data = event.data;
-      if (!data || typeof data !== "object" || data.type !== AUTHORIZATION_RESPONSE_MESSAGE_TYPE) return;
-      const response = data.response;
-      if (response.error) {
-        if (INTERACTIVE_AUTH_ERRORS.has(response.error)) {
-          finish(false);
-          return;
-        }
-        opts.onError?.({ error: response.error, description: response.error_description });
-        finish(true);
-        return;
-      }
-      if (!response.code) return;
-      if (response.state !== state) {
-        opts.onError?.({ error: ERROR_STATE_MISMATCH });
-        finish(true);
-        return;
-      }
-      try {
-        opts.onSuccess?.(await exchangeAuthorizationCode(callbackUri, pkce, state, response.code));
-      } catch (e) {
-        const err2 = e;
-        opts.onError?.({
-          error: err2.error ?? ERROR_CALLBACK_EXCEPTION,
-          description: err2.description ?? String(e)
-        });
-      }
-      finish(true);
-    };
-    window.addEventListener("message", handler);
-    document.body.appendChild(iframe);
-  });
-}
-function resolveAuthorizeEndpoint(opts) {
-  if (opts.authUrl) {
-    return Promise.resolve(`${opts.authUrl.replace(/\/$/, "")}/oauth/authorize`);
-  }
-  return getAuthorizationEndpoint(opts.issuer ?? DEFAULT_ISSUER);
-}
-async function startSignIn(opts) {
-  const callbackUri = opts.callbackUri ?? "/auth/callback";
-  const pkce = await generatePkce();
-  const state = generateState();
-  const authorizeEndpoint = await resolveAuthorizeEndpoint(opts);
-  if ((opts.mode ?? "redirect") === "redirect") {
-    startRedirectSignIn(opts, authorizeEndpoint, pkce, state);
-    return;
-  }
-  if (opts.silentFirst && !opts.prompt) {
-    const handledSilently = await trySilentModalSignIn(opts, authorizeEndpoint, callbackUri, pkce, state);
-    if (handledSilently) {
-      return;
-    }
-  }
-  const src = buildAuthorizeUrl(opts, authorizeEndpoint, pkce, state, {
-    responseMode: RESPONSE_MODE_WEB_MESSAGE,
-    prompt: opts.prompt
-  });
-  const expectedOrigin = new URL(authorizeEndpoint).origin;
-  let completed = false;
-  let handler = () => {
-  };
-  const modal = openModalIframe({
-    src,
-    onClose: () => {
-      window.removeEventListener("message", handler);
-      if (!completed) {
-        opts.onError?.({ error: ERROR_CANCELLED });
-      }
-    }
-  });
-  handler = async (event) => {
-    if (event.origin !== expectedOrigin) return;
-    const data = event.data;
-    if (!data || typeof data !== "object" || data.type !== AUTHORIZATION_RESPONSE_MESSAGE_TYPE) return;
-    const response = data.response;
-    if (response.error) {
-      completed = true;
-      modal.close();
-      opts.onError?.({ error: response.error, description: response.error_description });
-      return;
-    }
-    if (!response.code) return;
-    if (response.state !== state) {
-      completed = true;
-      modal.close();
-      opts.onError?.({ error: ERROR_STATE_MISMATCH });
-      return;
-    }
-    try {
-      const result = await exchangeAuthorizationCode(callbackUri, pkce, state, response.code);
-      completed = true;
-      modal.close();
-      opts.onSuccess?.(result);
-    } catch (e) {
-      const err2 = e;
-      completed = true;
-      opts.onError?.({
-        error: err2.error ?? ERROR_CALLBACK_EXCEPTION,
-        description: err2.description ?? String(e)
-      });
-      modal.close();
-    }
-  };
-  window.addEventListener("message", handler);
-}
-function startRedirectSignIn(opts, authorizeEndpoint, pkce, state) {
-  const returnTo = opts.returnTo ?? window.location.pathname + window.location.search;
-  const cookieValue = encodePkceState({ verifier: pkce.verifier, state, returnTo });
-  const secure = window.location.protocol === "https:" ? "; Secure" : "";
-  document.cookie = `${PKCE_COOKIE}=${cookieValue}; Path=${PKCE_COOKIE_PATH}; Max-Age=${PKCE_COOKIE_MAX_AGE_SECONDS}; SameSite=Lax${secure}`;
-  window.location.assign(buildAuthorizeUrl(opts, authorizeEndpoint, pkce, state, {
-    responseMode: RESPONSE_MODE_QUERY,
-    prompt: opts.prompt
-  }));
-}
-
-// src/internal/events.ts
-var MUTATION_ERROR = "mutation:error";
-var AUTH_TOKEN_CHANGED = "auth:token-changed";
-var SESSION_CLAIMED = "session:claimed";
-var SESSION_CLEARED = "session:cleared";
-function createClientEvents() {
-  const listeners = /* @__PURE__ */ new Map();
-  return {
-    on(name, listener) {
-      let set = listeners.get(name);
-      if (!set) {
-        set = /* @__PURE__ */ new Set();
-        listeners.set(name, set);
-      }
-      set.add(listener);
-      return () => {
-        set?.delete(listener);
-      };
-    },
-    off(name, listener) {
-      listeners.get(name)?.delete(listener);
-    },
-    emit(name, payload) {
-      const set = listeners.get(name);
-      if (!set) return;
-      const snapshot = Array.from(set);
-      for (const listener of snapshot) {
-        try {
-          listener(payload);
-        } catch (err2) {
-          console.error(`[Cimplify] event listener for "${name}" threw:`, err2);
-        }
-      }
-    }
-  };
-}
-
-// src/elements.ts
-function toCheckoutError(code, message, recoverable) {
-  const hint = chunkANT574FD_js.getErrorHint(code);
-  return {
-    success: false,
-    error: {
-      code,
-      message,
-      recoverable,
-      docs_url: hint?.docs_url,
-      suggestion: hint?.suggestion
-    }
-  };
-}
-var DEFAULT_LINK_URL = "https://link.cimplify.io";
-var AUTH_CONTACT_TYPES = new Set(Object.values(ELEMENTS_AUTH_CONTACT_TYPES));
-var AUTH_MODES = new Set(Object.values(ELEMENTS_AUTH_MODES));
-var AUTH_PROMPTS = new Set(Object.values(ELEMENTS_AUTH_PROMPTS));
-function generateNonce() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID().replace(/-/g, "").slice(0, 16);
-  }
-  return Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
-}
-function readPublicEnv(name) {
-  try {
-    const processLike = globalThis.process;
-    const value = processLike?.env?.[name];
-    return value && value.trim() ? value : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function decodeJwtSub(token) {
-  const [, payload] = token.split(".");
-  if (!payload || typeof atob === "undefined") return "";
-  try {
-    const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
-    const padded = base64.padEnd(base64.length + (4 - base64.length % 4) % 4, "=");
-    const parsed = JSON.parse(atob(padded));
-    return typeof parsed.sub === "string" ? parsed.sub : "";
-  } catch {
-    return "";
-  }
-}
-function isClaimedCustomer(value) {
-  if (!value || typeof value !== "object") return false;
-  const record = value;
-  return typeof record.id === "string" && typeof record.name === "string" && (record.email === null || typeof record.email === "string") && (record.phone === null || typeof record.phone === "string");
-}
-function isAllowedOrigin(origin) {
-  try {
-    const url = new URL(origin);
-    const hostname = url.hostname;
-    if (hostname === "localhost" || hostname === "127.0.0.1") {
-      return true;
-    }
-    if (url.protocol !== "https:") {
-      return false;
-    }
-    return hostname === "cimplify.io" || hostname.endsWith(".cimplify.io");
-  } catch {
-    return false;
-  }
-}
-var KNOWN_IFRAME_TYPES = /* @__PURE__ */ new Set([
-  MESSAGE_TYPES.READY,
-  MESSAGE_TYPES.HEIGHT_CHANGE,
-  MESSAGE_TYPES.AUTH_REQUESTED,
-  MESSAGE_TYPES.SESSION_ESTABLISHED,
-  MESSAGE_TYPES.CONTINUE_WITHOUT_SAVED_DETAILS,
-  MESSAGE_TYPES.ERROR,
-  MESSAGE_TYPES.ADDRESS_CHANGED,
-  MESSAGE_TYPES.ADDRESS_SELECTED,
-  MESSAGE_TYPES.PAYMENT_METHOD_SELECTED,
-  MESSAGE_TYPES.CONTACT_PROVIDED,
-  MESSAGE_TYPES.LOGOUT_COMPLETE,
-  MESSAGE_TYPES.CHECKOUT_STATUS,
-  MESSAGE_TYPES.CHECKOUT_COMPLETE,
-  MESSAGE_TYPES.TERMS_CHANGED,
-  MESSAGE_TYPES.SELECTION_UNAVAILABLE,
-  MESSAGE_TYPES.ORDER_TYPE_CHANGED,
-  MESSAGE_TYPES.REQUEST_SUBMIT
-]);
-function parseIframeMessage(data) {
-  if (!data || typeof data !== "object") {
-    return null;
-  }
-  const record = data;
-  if (typeof record.type !== "string" || !KNOWN_IFRAME_TYPES.has(record.type)) {
-    return null;
-  }
-  switch (record.type) {
-    case MESSAGE_TYPES.AUTH_REQUESTED:
-      if (record.loginHint !== void 0 && typeof record.loginHint !== "string") return null;
-      if (record.contactType !== void 0 && (typeof record.contactType !== "string" || !AUTH_CONTACT_TYPES.has(record.contactType))) {
-        return null;
-      }
-      if (record.mode !== void 0 && (typeof record.mode !== "string" || !AUTH_MODES.has(record.mode))) {
-        return null;
-      }
-      if (record.prompt !== void 0 && (typeof record.prompt !== "string" || !AUTH_PROMPTS.has(record.prompt))) {
-        return null;
-      }
-      break;
-    case MESSAGE_TYPES.SESSION_ESTABLISHED:
-      if (typeof record.sessionToken !== "string" || !record.sessionToken.trim()) return null;
-      if (typeof record.accessToken !== "string" || !record.accessToken.trim()) return null;
-      if (record.refreshToken !== void 0 && typeof record.refreshToken !== "string") return null;
-      if (!isClaimedCustomer(record.customer)) return null;
-      break;
-    case MESSAGE_TYPES.ADDRESS_CHANGED:
-    case MESSAGE_TYPES.ADDRESS_SELECTED:
-      if (!record.address || typeof record.address !== "object") return null;
-      break;
-    case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
-      if (!record.method || typeof record.method !== "object") return null;
-      break;
-    case MESSAGE_TYPES.CONTACT_PROVIDED:
-    case MESSAGE_TYPES.CONTINUE_WITHOUT_SAVED_DETAILS:
-      if (typeof record.contact !== "string" || typeof record.contactType !== "string") return null;
-      break;
-    case MESSAGE_TYPES.ERROR:
-      if (typeof record.code !== "string" || typeof record.message !== "string") return null;
-      break;
-    case MESSAGE_TYPES.CHECKOUT_COMPLETE:
-      if (typeof record.success !== "boolean") return null;
-      break;
-    case MESSAGE_TYPES.CHECKOUT_STATUS:
-      if (typeof record.status !== "string" || !record.context || typeof record.context !== "object")
-        return null;
-      break;
-    case MESSAGE_TYPES.TERMS_CHANGED:
-      if (typeof record.intent_id !== "string" || !record.replacement || typeof record.replacement !== "object" || !Array.isArray(record.deltas))
-        return null;
-      break;
-    case MESSAGE_TYPES.SELECTION_UNAVAILABLE:
-      if (typeof record.intent_id !== "string" || !Array.isArray(record.lines)) return null;
-      break;
-    case MESSAGE_TYPES.READY:
-    case MESSAGE_TYPES.HEIGHT_CHANGE:
-      if (typeof record.height !== "number") return null;
-      break;
-    case MESSAGE_TYPES.ORDER_TYPE_CHANGED:
-      if (typeof record.orderType !== "string") return null;
-      break;
-  }
-  return data;
-}
-var CimplifyElements = class {
-  constructor(client, businessId, options = {}) {
-    this.elements = /* @__PURE__ */ new Map();
-    this.accessToken = null;
-    this.accountId = null;
-    this.customerId = null;
-    this.customerData = null;
-    this.addressData = null;
-    this.paymentData = null;
-    this.checkoutInProgress = false;
-    this.authInProgress = false;
-    this.authGeneration = 0;
-    this.activeCheckoutAbort = null;
-    this.businessIdResolvePromise = null;
-    this.stopSessionSync = () => {
-    };
-    this.client = client;
-    this.businessId = businessId ?? null;
-    this.linkUrl = options.linkUrl || DEFAULT_LINK_URL;
-    this.options = options;
-    this.boundHandleMessage = this.handleMessage.bind(this);
-    if (typeof window !== "undefined") {
-      window.addEventListener("message", this.boundHandleMessage);
-    }
-    this.stopSessionSync = client.events.on(SESSION_CLAIMED, () => {
-      if (!this.authInProgress) this._syncHostSession();
-    });
-    void this.restoreSession();
-  }
-  debug(...args) {
-    if (this.client.isTestMode()) {
-      console.debug(...args);
-    }
-  }
-  _syncHostSession(element) {
-    const sessionToken = this.client.getSessionToken();
-    if (!sessionToken) return;
-    const identity = {
-      type: MESSAGE_TYPES.IDENTITY,
-      sessionToken,
-      accessToken: this.client.getAccessToken() ?? this.accessToken,
-      customer: this.identityCustomer()
-    };
-    const targets = element ? [element] : Array.from(this.elements.values());
-    for (const target of targets) {
-      target.sendMessage(identity);
-    }
-  }
-  identityCustomer() {
-    if (!this.accessToken || !this.customerId || !this.customerData) return null;
-    return { id: this.customerId, ...this.customerData };
-  }
-  create(type, options = {}) {
-    const existing = this.elements.get(type);
-    if (existing) return existing;
-    const element = new CimplifyElement(type, this.businessId, this.linkUrl, options, this);
-    this.elements.set(type, element);
-    return element;
-  }
-  getElement(type) {
-    return this.elements.get(type);
-  }
-  _removeElement(type, instance) {
-    const current = this.elements.get(type);
-    if (current === instance) {
-      this.elements.delete(type);
-    }
-  }
-  destroy() {
-    this.authGeneration += 1;
-    this.authInProgress = false;
-    this.stopSessionSync();
-    this.stopSessionSync = () => {
-    };
-    this.elements.forEach((element) => element.destroy());
-    this.elements.clear();
-    if (typeof window !== "undefined") {
-      window.removeEventListener("message", this.boundHandleMessage);
-    }
-  }
-  async submitCheckout(data) {
-    const result = await this.processCheckout({
-      cart_id: data.cart_id,
-      intent_id: data.intent_id,
-      hosted_session_id: data.hosted_session_id,
-      initial_terms: data.initial_terms,
-      order_type: data.order_type ?? chunkEV2EVOYS_js.ORDER_TYPE.DELIVERY,
-      location_id: data.location_id,
-      notes: data.notes,
-      scheduled_time: data.scheduled_time,
-      tip_amount: data.tip_amount,
-      enroll_in_link: true
-    });
-    if (result.success) {
-      return {
-        success: true,
-        order: {
-          id: result.order?.id || "",
-          status: result.order?.status || chunkEV2EVOYS_js.CHECKOUT_ORDER_RESULT_STATUS.UNKNOWN,
-          total: result.order?.total || ""
-        }
-      };
-    }
-    return {
-      success: false,
-      error: {
-        code: result.error?.code || chunkANT574FD_js.ErrorCode.CHECKOUT_FAILED,
-        message: result.error?.message || "Checkout failed"
-      }
-    };
-  }
-  processCheckout(options) {
-    let abortFn = null;
-    const task = (async () => {
-      this.debug("[cimplify:checkout] processCheckout called", {
-        cart_id: options.cart_id,
-        intent_id: options.intent_id,
-        hosted_session_id: options.hosted_session_id,
-        order_type: options.order_type,
-        location_id: options.location_id
-      });
-      if (this.checkoutInProgress) {
-        this.debug("[cimplify:checkout] BLOCKED: already processing");
-        return toCheckoutError(
-          chunkANT574FD_js.ErrorCode.ALREADY_PROCESSING,
-          "Checkout is already in progress.",
-          false
-        );
-      }
-      this.checkoutInProgress = true;
-      if (!options.cart_id && !options.intent_id) {
-        this.debug("[cimplify:checkout] BLOCKED: no cart_id or intent_id");
-        this.checkoutInProgress = false;
-        return toCheckoutError(
-          chunkANT574FD_js.ErrorCode.CHECKOUT_AUTHORITY_REQUIRED,
-          "A cart or existing purchase intent is required before checkout can start.",
-          false
-        );
-      }
-      if (!options.order_type) {
-        this.debug("[cimplify:checkout] BLOCKED: no order_type");
-        this.checkoutInProgress = false;
-        return toCheckoutError(
-          chunkANT574FD_js.ErrorCode.ORDER_TYPE_REQUIRED,
-          "Order type is required before checkout can start.",
-          false
-        );
-      }
-      const checkoutElement = this.elements.get(ELEMENT_TYPES.CHECKOUT) || this.elements.get(ELEMENT_TYPES.PAYMENT);
-      if (!checkoutElement) {
-        this.debug("[cimplify:checkout] BLOCKED: no checkout element");
-        this.checkoutInProgress = false;
-        return toCheckoutError(
-          chunkANT574FD_js.ErrorCode.NO_PAYMENT_ELEMENT,
-          "Checkout element must be mounted before checkout.",
-          false
-        );
-      }
-      if (!checkoutElement.isMounted()) {
-        this.debug("[cimplify:checkout] BLOCKED: checkout element not mounted");
-        this.checkoutInProgress = false;
-        return toCheckoutError(
-          chunkANT574FD_js.ErrorCode.PAYMENT_NOT_MOUNTED,
-          "Checkout element must be mounted before checkout.",
-          false
-        );
-      }
-      const isUnifiedCheckout = this.elements.has(ELEMENT_TYPES.CHECKOUT);
-      if (!isUnifiedCheckout) {
-        const authElement = this.elements.get(ELEMENT_TYPES.AUTH);
-        if (authElement && !this.accessToken) {
-          this.debug("[cimplify:checkout] BLOCKED: auth incomplete");
-          this.checkoutInProgress = false;
-          return toCheckoutError(
-            chunkANT574FD_js.ErrorCode.AUTH_INCOMPLETE,
-            "Authentication must complete before checkout can start.",
-            true
-          );
-        }
-        const addressElement = this.elements.get(ELEMENT_TYPES.ADDRESS);
-        if (addressElement) {
-          this.debug("[cimplify:checkout] getting address data...");
-          await addressElement.getData();
-          this.debug("[cimplify:checkout] address data resolved", this.addressData);
-        }
-        await this.hydrateCustomerData();
-      }
-      this.debug("[cimplify:checkout] customer data hydrated", {
-        customerData: this.customerData,
-        accountId: this.accountId,
-        isUnifiedCheckout
-      });
-      const processMessage = {
-        type: MESSAGE_TYPES.PROCESS_CHECKOUT,
-        // Existing intent authority wins if a compatibility caller supplied
-        // both values; the iframe must never mint a replacement.
-        cart_id: options.intent_id ? void 0 : options.cart_id,
-        intent_id: options.intent_id,
-        hosted_session_id: options.hosted_session_id,
-        initial_terms: options.intent_id ? options.initial_terms : void 0,
-        order_type: options.order_type,
-        location_id: options.location_id,
-        notes: options.notes,
-        scheduled_time: options.scheduled_time,
-        tip_amount: options.tip_amount,
-        pay_currency: options.pay_currency,
-        enroll_in_link: options.enroll_in_link ?? true,
-        address: isUnifiedCheckout ? void 0 : this.addressData ?? void 0,
-        customer: isUnifiedCheckout ? void 0 : this.customerData ? {
-          name: this.customerData.name,
-          email: this.customerData.email,
-          phone: this.customerData.phone
-        } : null,
-        account_id: this.accountId ?? void 0,
-        customer_id: this.customerId ?? void 0
-      };
-      const inactivityTimeoutMs = options.timeout_ms ?? 18e4;
-      const shopperPendingStatuses = /* @__PURE__ */ new Set([
-        chunkEV2EVOYS_js.CHECKOUT_STATUS.REVIEWING_TERMS,
-        chunkEV2EVOYS_js.CHECKOUT_STATUS.AWAITING_AUTHORIZATION
-      ]);
-      return new Promise((resolve) => {
-        let settled = false;
-        let timeout;
-        const cleanup = () => {
-          if (typeof window !== "undefined") {
-            window.removeEventListener("message", handleCheckoutMessage);
-          }
-          clearTimeout(timeout);
-          this.checkoutInProgress = false;
-          this.activeCheckoutAbort = null;
-        };
-        const settle = (result) => {
-          if (settled) {
-            return;
-          }
-          settled = true;
-          cleanup();
-          resolve(result);
-        };
-        const armTimeout = () => {
-          clearTimeout(timeout);
-          timeout = setTimeout(() => {
-            settle(
-              toCheckoutError(
-                chunkANT574FD_js.ErrorCode.TIMEOUT,
-                "Checkout timed out before receiving a terminal response.",
-                true
-              )
-            );
-          }, inactivityTimeoutMs);
-        };
-        const suspendTimeout = () => {
-          clearTimeout(timeout);
-          timeout = void 0;
-        };
-        armTimeout();
-        const handleCheckoutMessage = (event) => {
-          if (!isAllowedOrigin(event.origin)) {
-            return;
-          }
-          const message = parseIframeMessage(event.data);
-          if (!message) {
-            return;
-          }
-          if (!checkoutElement._acceptsMessageEvent(event, message)) {
-            return;
-          }
-          if (message.type === MESSAGE_TYPES.CHECKOUT_STATUS) {
-            if (shopperPendingStatuses.has(message.status)) {
-              suspendTimeout();
-            } else {
-              armTimeout();
-            }
-            options.on_status_change?.(message.status, message.context);
-            return;
-          }
-          if (message.type === MESSAGE_TYPES.TERMS_CHANGED) {
-            suspendTimeout();
-            options.on_status_change?.(chunkEV2EVOYS_js.CHECKOUT_STATUS.REVIEWING_TERMS, {
-              intent_id: message.intent_id,
-              replacement_terms: message.replacement,
-              terms_deltas: message.deltas
-            });
-            return;
-          }
-          if (message.type === MESSAGE_TYPES.SELECTION_UNAVAILABLE) {
-            suspendTimeout();
-            options.on_status_change?.(chunkEV2EVOYS_js.CHECKOUT_STATUS.REVIEWING_TERMS, {
-              intent_id: message.intent_id,
-              unavailable_lines: message.lines
-            });
-            return;
-          }
-          if (message.type === MESSAGE_TYPES.CHECKOUT_COMPLETE) {
-            this.debug("[cimplify:checkout] received checkout_complete", {
-              success: message.success,
-              error: message.error
-            });
-            settle({
-              success: message.success,
-              order: message.order,
-              error: message.error,
-              enrolled_in_link: message.enrolled_in_link
-            });
-          }
-          if (message.type === MESSAGE_TYPES.LOGOUT_COMPLETE) {
-            checkoutElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT });
-            settle(
-              toCheckoutError(
-                chunkANT574FD_js.ErrorCode.AUTH_LOST,
-                "Authentication was cleared during checkout.",
-                true
-              )
-            );
-          }
-        };
-        if (typeof window !== "undefined") {
-          window.addEventListener("message", handleCheckoutMessage);
-        }
-        abortFn = () => {
-          checkoutElement.sendMessage({ type: MESSAGE_TYPES.ABORT_CHECKOUT });
-          settle(toCheckoutError(chunkANT574FD_js.ErrorCode.CANCELLED, "Checkout was cancelled.", true));
-        };
-        this.activeCheckoutAbort = abortFn;
-        this.debug("[cimplify:checkout] sending process_checkout to checkout iframe", {
-          cart_id: processMessage.cart_id,
-          intent_id: processMessage.intent_id,
-          hosted_session_id: processMessage.hosted_session_id,
-          order_type: processMessage.order_type,
-          hasCustomer: !!processMessage.customer,
-          hasAddress: !!processMessage.address,
-          isUnifiedCheckout
-        });
-        this._syncHostSession(checkoutElement);
-        checkoutElement.sendMessage(processMessage);
-        this.debug("[cimplify:checkout] postMessage sent, waiting for checkout_complete...");
-      });
-    })();
-    const abortable = task;
-    abortable.abort = () => {
-      if (abortFn) {
-        abortFn();
-      }
-    };
-    return abortable;
-  }
-  isAuthenticated() {
-    return this.accessToken !== null;
-  }
-  getAccessToken() {
-    return this.accessToken;
-  }
-  getPublicKey() {
-    return this.client.getPublicKey();
-  }
-  getSessionToken() {
-    return this.client.getSessionToken();
-  }
-  getBusinessId() {
-    return this.businessId;
-  }
-  async resolveBusinessId() {
-    if (this.businessId) {
-      return this.businessId;
-    }
-    if (this.businessIdResolvePromise) {
-      return this.businessIdResolvePromise;
-    }
-    this.businessIdResolvePromise = this.client.resolveBusinessId().then((resolvedBusinessId) => {
-      this.businessId = resolvedBusinessId;
-      return resolvedBusinessId;
-    }).catch(() => null).finally(() => {
-      this.businessIdResolvePromise = null;
-    });
-    return this.businessIdResolvePromise;
-  }
-  getAppearance() {
-    return this.options.appearance;
-  }
-  isAuthGenerationCurrent(generation, token) {
-    return this.authGeneration === generation && this.client.getAccessToken() === token;
-  }
-  async hydrateCustomerData(generation = this.authGeneration, token = this.accessToken, force = false) {
-    if (!token || !this.isAuthGenerationCurrent(generation, token)) return false;
-    if (this.customerData && !force) return true;
-    const linkDataResult = await this.client.link.getLinkData();
-    if (!this.isAuthGenerationCurrent(generation, token)) return false;
-    if (!linkDataResult.ok || !linkDataResult.value?.customer) {
-      return true;
-    }
-    const customer = linkDataResult.value.customer;
-    this.customerData = {
-      name: customer.name || "",
-      email: customer.email || null,
-      phone: customer.phone || null
-    };
-    this.customerId = customer.id;
-    return true;
-  }
-  sourceElementFor(event, message) {
-    for (const element of this.elements.values()) {
-      if (element._acceptsMessageEvent(event, message)) {
-        return element;
-      }
-    }
-    return null;
-  }
-  // Refresh token kept first-party (keyed by public key) so a signed-in shopper
-  // survives reloads. Standard SPA tradeoff; far safer than the third-party
-  // iframe, whose storage/cookies are partitioned or blocked.
-  sessionStorageKey() {
-    const key = this.client.getPublicKey().trim();
-    return key ? `cimplify.link.rt.${key}` : null;
-  }
-  persistRefreshToken(refreshToken) {
-    if (typeof window === "undefined") return;
-    const storageKey = this.sessionStorageKey();
-    if (!storageKey) return;
-    try {
-      if (refreshToken) {
-        window.localStorage.setItem(storageKey, refreshToken);
-      } else {
-        window.localStorage.removeItem(storageKey);
-      }
-    } catch {
-    }
-  }
-  clearPersistedSession() {
-    if (typeof window === "undefined") return;
-    const storageKey = this.sessionStorageKey();
-    if (!storageKey) return;
-    try {
-      window.localStorage.removeItem(storageKey);
-    } catch {
-    }
-  }
-  clearClaimedAuthorityAfterRestoreFailure() {
-    if (!this.client.getAccessToken() && !this.client.hasClaimedSessionAuthority()) return;
-    this.accessToken = null;
-    this.accountId = null;
-    this.customerId = null;
-    this.customerData = null;
-    this.addressData = null;
-    this.paymentData = null;
-    this.client.clearSession();
-    this.broadcastClearedSession();
-  }
-  async restoreSession() {
-    if (typeof window === "undefined" || this.accessToken) return;
-    const generation = ++this.authGeneration;
-    const storageKey = this.sessionStorageKey();
-    if (!storageKey) return;
-    let refreshToken = null;
-    try {
-      refreshToken = window.localStorage.getItem(storageKey);
-    } catch {
-      this.clearClaimedAuthorityAfterRestoreFailure();
-      return;
-    }
-    if (!refreshToken) {
-      this.clearClaimedAuthorityAfterRestoreFailure();
-      return;
-    }
-    const result = await this.client.link.refreshSession(refreshToken, {
-      activateSession: false
-    });
-    if (this.authGeneration !== generation) return;
-    if (!result.ok || !result.value.session_token) {
-      this.clearPersistedSession();
-      this.clearClaimedAuthorityAfterRestoreFailure();
-      return;
-    }
-    this.persistRefreshToken(result.value.refresh_token ?? void 0);
-    const application = await this.applyAccessToken(result.value.session_token, generation);
-    if (application.kind === "claim_failed") {
-      this.clearPersistedSession();
-      this.broadcastClearedSession();
-      return;
-    }
-    if (application.kind !== "authenticated") return;
-    this._syncHostSession();
-    this.elements.forEach((element) => element._emitAuthenticated(application.data));
-  }
-  async applyAccessToken(token, generation) {
-    if (this.authGeneration !== generation) return { kind: "incomplete" };
-    this.accessToken = null;
-    this.accountId = null;
-    this.customerId = null;
-    this.customerData = null;
-    this.addressData = null;
-    this.paymentData = null;
-    this.client.setAccessToken(token);
-    const claim = await this.client.session.claim();
-    if (!this.isAuthGenerationCurrent(generation, token)) return { kind: "incomplete" };
-    if (!claim.ok && claim.error.code !== "already_claimed") {
-      if (this.client.hasClaimedSessionAuthority()) {
-        this.client.clearSession();
-      } else {
-        this.client.setAccessToken(null);
-      }
-      return {
-        kind: "claim_failed",
-        code: claim.error.code,
-        message: claim.error.userMessage
-      };
-    }
-    this.accessToken = token;
-    this.accountId = decodeJwtSub(token);
-    if (!await this.hydrateCustomerData(generation, token, true)) {
-      return { kind: "incomplete" };
-    }
-    if (!this.isAuthGenerationCurrent(generation, token)) return { kind: "incomplete" };
-    return {
-      kind: "authenticated",
-      data: {
-        accountId: this.accountId ?? "",
-        customerId: this.customerId ?? "",
-        token,
-        customer: this.customerData ?? { name: "", email: null, phone: null }
-      }
-    };
-  }
-  adoptEstablishedSession(sourceElement, session) {
-    this.authGeneration += 1;
-    this.authInProgress = false;
-    const { id, ...customer } = session.customer;
-    this.accessToken = session.accessToken;
-    this.accountId = decodeJwtSub(session.accessToken);
-    this.customerId = id;
-    this.customerData = customer;
-    this.addressData = null;
-    this.paymentData = null;
-    this.client.setAccessToken(session.accessToken);
-    this.persistRefreshToken(session.refreshToken);
-    this.client.session.adopt(session.accessToken, {
-      sessionToken: session.sessionToken,
-      customerName: session.customer.name,
-      customer: session.customer,
-      cart: null
-    });
-    sourceElement._emitAuthenticated({
-      accountId: this.accountId,
-      customerId: id,
-      token: session.accessToken,
-      customer
-    });
-  }
-  broadcastClearedSession() {
-    const sessionToken = this.client.getSessionToken();
-    if (!sessionToken) return null;
-    this.elements.forEach((element) => {
-      element.sendMessage({ type: MESSAGE_TYPES.SESSION_CLEARED, sessionToken });
-    });
-    return sessionToken;
-  }
-  startEmbeddedAuth(sourceElement, request) {
-    if (this.authInProgress) return;
-    const auth = this.options.auth ?? {};
-    const clientId = auth.clientId ?? readPublicEnv("NEXT_PUBLIC_CIMPLIFY_CLIENT_ID");
-    const redirectUri = auth.redirectUri ?? readPublicEnv("NEXT_PUBLIC_CIMPLIFY_REDIRECT_URI");
-    if (!clientId || !redirectUri) {
-      sourceElement._emitError({
-        code: chunkANT574FD_js.ErrorCode.AUTH_CONFIG_REQUIRED,
-        message: "Cimplify OAuth clientId and redirectUri are required."
-      });
-      return;
-    }
-    const generation = ++this.authGeneration;
-    this.authInProgress = true;
-    void startSignIn({
-      clientId,
-      redirectUri,
-      callbackUri: auth.callbackUri,
-      scope: auth.scope,
-      issuer: auth.issuer,
-      authUrl: auth.authUrl,
-      loginHint: request.loginHint,
-      prompt: request.prompt,
-      uiMode: request.mode,
-      mode: "modal",
-      silentFirst: request.mode === ELEMENTS_AUTH_MODES.CHECKOUT && request.prompt !== ELEMENTS_AUTH_PROMPTS.LOGIN,
-      onSuccess: async ({ accessToken }) => {
-        if (this.authGeneration !== generation) return;
-        this.authInProgress = false;
-        if (!accessToken) {
-          sourceElement._emitError({
-            code: chunkANT574FD_js.ErrorCode.AUTH_CALLBACK_MISSING_TOKEN,
-            message: "Sign-in callback did not return an access token."
-          });
-          return;
-        }
-        const application = await this.applyAccessToken(accessToken, generation);
-        if (application.kind === "authenticated") {
-          this._syncHostSession();
-          sourceElement._emitAuthenticated(application.data);
-        } else if (application.kind === "claim_failed") {
-          sourceElement._emitError({
-            code: application.code,
-            message: application.message
-          });
-        }
-      },
-      onError: (err2) => {
-        if (this.authGeneration !== generation) return;
-        this.authInProgress = false;
-        sourceElement._emitError({
-          code: err2.error,
-          message: err2.description ?? err2.error
-        });
-      }
-    }).catch((error) => {
-      if (this.authGeneration !== generation) return;
-      this.authInProgress = false;
-      sourceElement._emitError({
-        code: chunkANT574FD_js.ErrorCode.AUTH_START_FAILED,
-        message: error instanceof Error ? error.message : "Unable to start sign-in."
-      });
-    });
-  }
-  handleMessage(event) {
-    if (!isAllowedOrigin(event.origin)) {
-      return;
-    }
-    const message = parseIframeMessage(event.data);
-    if (!message) return;
-    const sourceElement = this.sourceElementFor(event, message);
-    if (!sourceElement) return;
-    switch (message.type) {
-      case MESSAGE_TYPES.AUTH_REQUESTED:
-        this.startEmbeddedAuth(sourceElement, message);
-        break;
-      case MESSAGE_TYPES.SESSION_ESTABLISHED:
-        this.adoptEstablishedSession(sourceElement, message);
-        break;
-      case MESSAGE_TYPES.ADDRESS_CHANGED:
-      case MESSAGE_TYPES.ADDRESS_SELECTED:
-        this.addressData = message.address;
-        break;
-      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
-        this.paymentData = message.method;
-        break;
-      case MESSAGE_TYPES.CONTACT_PROVIDED:
-        if (!this.customerData) {
-          this.customerData = { name: "", email: null, phone: null };
-        }
-        if (message.contactType === ELEMENTS_AUTH_CONTACT_TYPES.EMAIL) {
-          this.customerData.email = message.contact;
-        } else {
-          this.customerData.phone = message.contact;
-        }
-        break;
-      case MESSAGE_TYPES.CONTINUE_WITHOUT_SAVED_DETAILS: {
-        this.authGeneration += 1;
-        this.authInProgress = false;
-        const carriedIdentityAuthority = Boolean(this.client.getAccessToken()) || this.client.hasClaimedSessionAuthority();
-        this.accessToken = null;
-        this.accountId = null;
-        this.customerId = null;
-        this.customerData = { name: "", email: null, phone: null };
-        this.addressData = null;
-        this.paymentData = null;
-        this.clearPersistedSession();
-        if (carriedIdentityAuthority) {
-          this.client.clearSession();
-        } else {
-          this.client.setAccessToken(null);
-        }
-        this.broadcastClearedSession();
-        if (message.contactType === ELEMENTS_AUTH_CONTACT_TYPES.EMAIL) {
-          this.customerData.email = message.contact;
-        } else {
-          this.customerData.phone = message.contact;
-        }
-        break;
-      }
-      case MESSAGE_TYPES.LOGOUT_COMPLETE:
-        this.authGeneration += 1;
-        this.authInProgress = false;
-        if (this.checkoutInProgress && this.activeCheckoutAbort) {
-          this.activeCheckoutAbort();
-        }
-        this.accessToken = null;
-        this.accountId = null;
-        this.customerId = null;
-        this.customerData = null;
-        this.addressData = null;
-        this.paymentData = null;
-        this.clearPersistedSession();
-        this.client.clearSession();
-        this.broadcastClearedSession();
-        break;
-    }
-  }
-  _setAddressData(data) {
-    this.addressData = data;
-  }
-  _setPaymentData(data) {
-    this.paymentData = data;
-  }
-  _setGuestContact(contact, contactType) {
-    if (!this.customerData) {
-      this.customerData = { name: "", email: null, phone: null };
-    }
-    if (contactType === ELEMENTS_AUTH_CONTACT_TYPES.EMAIL) {
-      this.customerData.email = contact;
-    } else {
-      this.customerData.phone = contact;
-    }
-  }
-};
-var CimplifyElement = class {
-  constructor(type, businessId, linkUrl, options, parent) {
-    this.iframe = null;
-    this.container = null;
-    this.mounted = false;
-    this.ready = false;
-    this.pendingMessages = [];
-    this.pendingInit = null;
-    this.eventHandlers = /* @__PURE__ */ new Map();
-    this.resolvers = /* @__PURE__ */ new Map();
-    this.lastReportedHeight = 0;
-    this.listening = false;
-    this.type = type;
-    this.businessId = businessId;
-    this.linkUrl = linkUrl;
-    this.options = options;
-    this.parent = parent;
-    this.nonce = generateNonce();
-    this.boundHandleMessage = this.handleMessage.bind(this);
-    this.boundHandleResize = () => this.applyHeight();
-    if (typeof window !== "undefined") {
-      window.addEventListener("message", this.boundHandleMessage);
-      window.addEventListener("resize", this.boundHandleResize);
-      this.listening = true;
-    }
-  }
-  /**
-   * Size the iframe to the element's reported content height (in pixels). We do
-   * NOT cap checkout at the viewport: capping forced a tall checkout to scroll
-   * *inside* a viewport-height iframe — a nested scroll-within-scroll. Sizing to
-   * content lets the iframe grow and the host page scroll naturally as one
-   * surface, which is the standard embedded-checkout behaviour.
-   */
-  applyHeight(reportedHeight) {
-    if (!this.iframe) return;
-    if (typeof reportedHeight === "number" && reportedHeight > 0) {
-      this.lastReportedHeight = reportedHeight;
-    }
-    const content = this.lastReportedHeight;
-    if (!content) return;
-    this.iframe.style.height = `${Math.max(320, content)}px`;
-  }
-  mount(container) {
-    if (this.mounted) {
-      console.warn(`Element ${this.type} is already mounted`);
-      return;
-    }
-    const target = typeof container === "string" ? document.querySelector(container) : container;
-    if (!target) {
-      console.error(`Container not found: ${container}`);
-      return;
-    }
-    this.container = target;
-    this.mounted = true;
-    if (!this.listening && typeof window !== "undefined") {
-      window.addEventListener("message", this.boundHandleMessage);
-      this.listening = true;
-    }
-    void this.createIframe();
-  }
-  destroy() {
-    if (this.iframe) {
-      this.iframe.remove();
-      this.iframe = null;
-    }
-    this.container = null;
-    this.mounted = false;
-    this.ready = false;
-    this.pendingMessages = [];
-    this.eventHandlers.clear();
-    this.resolvers.forEach((entry) => clearTimeout(entry.timeoutId));
-    this.resolvers.clear();
-    if (this.listening && typeof window !== "undefined") {
-      window.removeEventListener("message", this.boundHandleMessage);
-      window.removeEventListener("resize", this.boundHandleResize);
-      this.listening = false;
-    }
-    this.parent._removeElement(this.type, this);
-  }
-  on(event, handler) {
-    if (!this.eventHandlers.has(event)) {
-      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
-    }
-    this.eventHandlers.get(event).add(handler);
-  }
-  off(event, handler) {
-    this.eventHandlers.get(event)?.delete(handler);
-  }
-  async getData() {
-    if (!this.isMounted()) {
-      return null;
-    }
-    return new Promise((resolve) => {
-      const id = Math.random().toString(36).slice(2);
-      const timeoutId = setTimeout(() => {
-        const entry = this.resolvers.get(id);
-        if (!entry) {
-          return;
-        }
-        this.resolvers.delete(id);
-        entry.resolve(null);
-      }, 5e3);
-      this.resolvers.set(id, { resolve, timeoutId });
-      this.sendMessage({ type: MESSAGE_TYPES.GET_DATA });
-    });
-  }
-  setCart(cart) {
-    this.sendMessage({ type: MESSAGE_TYPES.SET_CART, cart });
-  }
-  sendMessage(message) {
-    const iframe = this.iframe;
-    if (!iframe || !iframe.isConnected) {
-      if (iframe && !iframe.isConnected) {
-        console.warn("[cimplify:checkout] sendMessage DROPPED \u2014 iframe detached", {
-          type: message.type
-        });
-      }
-      return;
-    }
-    if (!this.ready || !iframe.contentWindow) {
-      this.pendingMessages.push(message);
-      return;
-    }
-    iframe.contentWindow.postMessage(message, this.linkUrl);
-  }
-  flushPending() {
-    if (!this.ready || !this.iframe?.contentWindow) return;
-    const queue = this.pendingMessages;
-    this.pendingMessages = [];
-    for (const message of queue) {
-      this.iframe.contentWindow.postMessage(message, this.linkUrl);
-    }
-  }
-  getContentWindow() {
-    return this.iframe?.contentWindow ?? null;
-  }
-  isMounted() {
-    return this.mounted && Boolean(this.iframe) && this.iframe?.isConnected === true;
-  }
-  _acceptsMessageEvent(event, message) {
-    const iframeWindow = this.iframe?.contentWindow;
-    if (!iframeWindow || event.source !== iframeWindow) return false;
-    return message.nonce === this.nonce;
-  }
-  _emitAuthenticated(data) {
-    this.emit(EVENT_TYPES.AUTHENTICATED, data);
-  }
-  _emitError(error) {
-    this.emit(EVENT_TYPES.ERROR, error);
-  }
-  async createIframe() {
-    if (!this.container) return;
-    const resolvedBusinessId = this.businessId ?? await this.parent.resolveBusinessId();
-    if (!resolvedBusinessId || !this.container || !this.mounted) {
-      console.error("Unable to mount element without a resolved business ID");
-      this.emit(EVENT_TYPES.ERROR, {
-        code: chunkANT574FD_js.ErrorCode.BUSINESS_ID_REQUIRED,
-        message: "Unable to initialize checkout without a business ID."
-      });
-      return;
-    }
-    this.businessId = resolvedBusinessId;
-    const iframe = document.createElement("iframe");
-    const url = new URL(`${this.linkUrl}/elements/${this.type}`);
-    url.searchParams.set("businessId", resolvedBusinessId);
-    url.searchParams.set("nonce", this.nonce);
-    if (this.options.prefillEmail) url.searchParams.set("email", this.options.prefillEmail);
-    if (this.options.mode) url.searchParams.set("mode", this.options.mode);
-    iframe.src = url.toString();
-    iframe.style.border = "none";
-    iframe.style.width = "100%";
-    iframe.style.minHeight = "200px";
-    iframe.style.display = "block";
-    iframe.style.overflow = "hidden";
-    iframe.style.background = "transparent";
-    iframe.setAttribute("allowtransparency", "true");
-    iframe.setAttribute("frameborder", "0");
-    iframe.setAttribute("allow", "geolocation");
-    iframe.setAttribute(
-      "sandbox",
-      "allow-scripts allow-same-origin allow-forms allow-popups allow-popups-to-escape-sandbox"
-    );
-    this.iframe = iframe;
-    this.container.appendChild(iframe);
-    this.pendingInit = {
-      businessId: resolvedBusinessId,
-      publicKey: this.parent.getPublicKey()
-    };
-  }
-  handleMessage(event) {
-    if (!isAllowedOrigin(event.origin)) {
-      return;
-    }
-    const message = parseIframeMessage(event.data);
-    if (!message) return;
-    if (!this._acceptsMessageEvent(event, message)) return;
-    switch (message.type) {
-      case MESSAGE_TYPES.READY:
-        this.ready = true;
-        if (message.height) this.applyHeight(message.height);
-        if (this.pendingInit) {
-          const { publicKey } = this.pendingInit;
-          this.sendMessage({
-            type: MESSAGE_TYPES.INIT,
-            businessId: this.pendingInit.businessId,
-            publicKey,
-            prefillEmail: this.options.prefillEmail,
-            appearance: this.parent.getAppearance(),
-            orderTypes: this.options.orderTypes,
-            defaultOrderType: this.options.defaultOrderType,
-            renderSubmitButton: true,
-            submitLabel: this.options.submitLabel,
-            intentId: this.options.intentId,
-            hostedSessionId: this.options.hostedSessionId,
-            initialTerms: this.options.initialTerms
-          });
-          this.parent._syncHostSession(this);
-          this.pendingInit = null;
-        }
-        this.flushPending();
-        this.emit(EVENT_TYPES.READY, { height: message.height });
-        break;
-      case MESSAGE_TYPES.HEIGHT_CHANGE:
-        this.applyHeight(message.height);
-        break;
-      case MESSAGE_TYPES.ERROR:
-        this.emit(EVENT_TYPES.ERROR, { code: message.code, message: message.message });
-        break;
-      case MESSAGE_TYPES.ADDRESS_CHANGED:
-      case MESSAGE_TYPES.ADDRESS_SELECTED:
-        this.parent._setAddressData(message.address);
-        this.emit(EVENT_TYPES.CHANGE, { address: message.address });
-        this.resolveData(message.address);
-        break;
-      case MESSAGE_TYPES.PAYMENT_METHOD_SELECTED:
-        this.parent._setPaymentData(message.method);
-        this.emit(EVENT_TYPES.CHANGE, { paymentMethod: message.method });
-        this.resolveData(message.method);
-        break;
-      case MESSAGE_TYPES.CONTACT_PROVIDED:
-        this.parent._setGuestContact(message.contact, message.contactType);
-        break;
-      case MESSAGE_TYPES.ORDER_TYPE_CHANGED:
-        this.emit(EVENT_TYPES.ORDER_TYPE_CHANGED, { orderType: message.orderType });
-        break;
-      case MESSAGE_TYPES.REQUEST_SUBMIT:
-        this.emit(EVENT_TYPES.REQUEST_SUBMIT, {});
-        break;
-    }
-  }
-  emit(event, data) {
-    this.eventHandlers.get(event)?.forEach((handler) => handler(data));
-  }
-  resolveData(data) {
-    this.resolvers.forEach((entry) => {
-      clearTimeout(entry.timeoutId);
-      entry.resolve(data);
-    });
-    this.resolvers.clear();
-  }
-};
-function createElements(client, businessId, options) {
-  return new CimplifyElements(client, businessId, options);
-}
-
-exports.AUTH_TOKEN_CHANGED = AUTH_TOKEN_CHANGED;
-exports.AuthService = AuthService;
-exports.BusinessService = BusinessService;
-exports.CartOperations = CartOperations;
-exports.CatalogueQueries = CatalogueQueries;
-exports.CheckoutService = CheckoutService;
-exports.CimplifyElement = CimplifyElement;
-exports.CimplifyElements = CimplifyElements;
-exports.DEFAULT_ISSUER = DEFAULT_ISSUER;
-exports.ELEMENTS_AUTH_CONTACT_TYPES = ELEMENTS_AUTH_CONTACT_TYPES;
-exports.ELEMENTS_AUTH_MODES = ELEMENTS_AUTH_MODES;
-exports.ELEMENTS_AUTH_PROMPTS = ELEMENTS_AUTH_PROMPTS;
-exports.ELEMENT_TYPES = ELEMENT_TYPES;
-exports.EVENT_TYPES = EVENT_TYPES;
-exports.FxService = FxService;
-exports.InventoryService = InventoryService;
-exports.LinkService = LinkService;
-exports.LiteService = LiteService;
-exports.MESSAGE_TYPES = MESSAGE_TYPES;
-exports.MUTATION_ERROR = MUTATION_ERROR;
-exports.OrderQueries = OrderQueries;
-exports.PAYMENT_AUTHORIZATION_OUTCOME_STATUS = PAYMENT_AUTHORIZATION_OUTCOME_STATUS;
-exports.PAYMENT_AUTHORIZATION_PROVIDER = PAYMENT_AUTHORIZATION_PROVIDER;
-exports.PKCE_COOKIE = PKCE_COOKIE;
-exports.PKCE_COOKIE_PATH = PKCE_COOKIE_PATH;
-exports.PaymentAuthorizationAdapterRegistry = PaymentAuthorizationAdapterRegistry;
-exports.PaystackAuthorizationAdapter = PaystackAuthorizationAdapter;
-exports.SESSION_CLAIMED = SESSION_CLAIMED;
-exports.SESSION_CLEARED = SESSION_CLEARED;
-exports.SchedulingService = SchedulingService;
-exports.StripeAuthorizationAdapter = StripeAuthorizationAdapter;
-exports.clearIntentIdempotencyKey = clearIntentIdempotencyKey;
-exports.combine = combine;
-exports.combineObject = combineObject;
-exports.confirmationForUnchangedReplacement = confirmationForUnchangedReplacement;
-exports.createClientEvents = createClientEvents;
-exports.createDefaultPaymentAuthorizationAdapterRegistry = createDefaultPaymentAuthorizationAdapterRegistry;
-exports.createElements = createElements;
-exports.createPurchaseIntentConfirmation = createPurchaseIntentConfirmation;
-exports.decodePkceState = decodePkceState;
-exports.err = err;
-exports.flatMap = flatMap;
-exports.fromPromise = fromPromise;
-exports.generateIdempotencyKey = generateIdempotencyKey;
-exports.generatePkce = generatePkce;
-exports.generateState = generateState;
-exports.getAuthorizationEndpoint = getAuthorizationEndpoint;
-exports.getOrElse = getOrElse;
-exports.intentIdempotencyKey = intentIdempotencyKey;
-exports.isErr = isErr;
-exports.isOk = isOk;
-exports.mapError = mapError;
-exports.mapResult = mapResult;
-exports.ok = ok;
-exports.purchaseIntentRequiresPaymentOption = purchaseIntentRequiresPaymentOption;
-exports.safe = safe;
-exports.selectPurchaseIntentPaymentOption = selectPurchaseIntentPaymentOption;
-exports.startSignIn = startSignIn;
-exports.toNullable = toNullable;
-exports.tryCatch = tryCatch;
-exports.unwrap = unwrap;