@beworke/pixel-bemony 0.1.0-rc.1

package/dist/index.esm.js

@@ -0,0 +1,2081 @@
+// src/createBemonyPixelConfig.ts
+import { DEFAULT_PIXEL_CONFIG } from "@beworke/pixel";
+
+// src/domain/BemonyPageContext.ts
+var BemonyValidationError = class extends Error {
+  constructor(options) {
+    super(options.message);
+    this.name = "BemonyValidationError";
+    this.code = options.code;
+    this.field = options.field;
+    this.scenario = options.scenario;
+  }
+};
+function isBemonyPageContextInput(value) {
+  return typeof value === "object" && value !== null && "public" in value && typeof value.public === "object" && value.public !== null;
+}
+function normalizePublicPriceFields(publicContext) {
+  const priceCode = publicContext.priceCode?.trim() || void 0;
+  const priceId = publicContext.priceId?.trim() || void 0;
+  const { priceId: _legacy, ...rest } = publicContext;
+  if (priceCode) {
+    return { ...rest, priceCode };
+  }
+  if (priceId) {
+    return { ...rest, priceCode: priceId };
+  }
+  return { ...rest };
+}
+function normalizeBemonyPageContextInput(page) {
+  if (!page) {
+    return { public: {} };
+  }
+  if (isBemonyPageContextInput(page)) {
+    return {
+      public: normalizePublicPriceFields({ ...page.public })
+    };
+  }
+  return {
+    public: normalizePublicPriceFields({ ...page })
+  };
+}
+
+// src/domain/resolveBemonyPageContext.ts
+var PUBLIC_URL_PARAM_TO_FIELD = {
+  page_id: "pageId",
+  funnel_id: "funnelId",
+  funnel_step_id: "funnelStepId",
+  offer_id: "offerId",
+  product_id: "productId",
+  price_code: "priceCode",
+  price_id: "priceCode",
+  checkout_id: "checkoutId",
+  afid: "affiliateId",
+  fid: "funnelId",
+  fsid: "funnelStepId",
+  oid: "publicOrderId"
+};
+function pickDefined(source) {
+  if (!source) {
+    return {};
+  }
+  const result = {};
+  for (const key of Object.keys(source)) {
+    const value = source[key];
+    if (value !== void 0 && value !== "") {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function publicContextFromUrlParams(urlParams) {
+  if (!urlParams) {
+    return {};
+  }
+  const result = {};
+  for (const [rawKey, rawValue] of Object.entries(urlParams)) {
+    const field = PUBLIC_URL_PARAM_TO_FIELD[rawKey];
+    if (!field) {
+      continue;
+    }
+    if (rawValue === void 0 || rawValue === "") {
+      continue;
+    }
+    result[field] = rawValue;
+  }
+  return result;
+}
+function resolveBemonyPageContext(sources = {}) {
+  const fromScenario = pickDefined(sources.scenarioDefaults);
+  const fromMetadata = pickDefined(sources.pageMetadata);
+  const fromUrl = publicContextFromUrlParams(sources.urlParams);
+  const fromInput = pickDefined(sources.input);
+  return {
+    ...fromScenario,
+    ...fromMetadata,
+    ...fromUrl,
+    ...fromInput
+  };
+}
+
+// src/domain/validateBemonyPageContext.ts
+var MAX_ID_LENGTH = 128;
+var SAFE_ID_PATTERN = /^[a-zA-Z0-9_.:-]+$/;
+var REQUIRED_PUBLIC_FIELDS = {
+  "offer-page": [],
+  checkout: [],
+  "upsell-offer": [],
+  "one-click-checkout": [
+    "publicOrderId",
+    "funnelId",
+    "funnelStepId",
+    "priceCode"
+  ],
+  "thank-you": []
+};
+function assertSafePublicId(field, value, scenario) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new BemonyValidationError({
+      code: "INVALID_FIELD",
+      field,
+      scenario,
+      message: `Field "${field}" cannot be empty for scenario "${scenario}".`
+    });
+  }
+  if (trimmed.length > MAX_ID_LENGTH) {
+    throw new BemonyValidationError({
+      code: "INVALID_FIELD",
+      field,
+      scenario,
+      message: `Field "${field}" exceeds maximum length of ${MAX_ID_LENGTH}.`
+    });
+  }
+  if (!SAFE_ID_PATTERN.test(trimmed)) {
+    throw new BemonyValidationError({
+      code: "INVALID_FIELD",
+      field,
+      scenario,
+      message: `Field "${field}" contains invalid characters.`
+    });
+  }
+  return trimmed;
+}
+function validateBemonyPageContext(options) {
+  const { scenario } = options;
+  const sanitize = options.sanitize !== false;
+  const required = REQUIRED_PUBLIC_FIELDS[scenario];
+  const source = options.publicContext;
+  const result = {};
+  for (const field of Object.keys(
+    source
+  )) {
+    const value = source[field];
+    if (value === void 0) {
+      continue;
+    }
+    result[field] = sanitize ? assertSafePublicId(field, value, scenario) : value;
+  }
+  for (const field of required) {
+    if (!result[field]) {
+      throw new BemonyValidationError({
+        code: "MISSING_REQUIRED_FIELD",
+        field,
+        scenario,
+        message: `Field "${field}" is required for scenario "${scenario}".`
+      });
+    }
+  }
+  return result;
+}
+
+// src/platform/defaults.ts
+var BEMONY_STORAGE_PREFIX = "__bemony_pixel";
+var BEMONY_DEFAULT_NAMESPACE = "bemony-web";
+var BEMONY_DEFAULT_API_ENDPOINT = "https://micro-service-pixel-production-4826.up.railway.app";
+var BEMONY_DEFAULT_PIXEL_ID = "pix_7704308";
+var BEMONY_DEFAULT_ALLOWED_DOMAINS = [
+  "security.bemony.com",
+  /** Serve HTTP local (`pnpm dlx serve`). */
+  "localhost",
+  "127.0.0.1",
+  /**
+   * Sentinel interno: permite links relativos / `file://` (hostname vazio)
+   * no LinkDecorator — só para simulação local dos examples.
+   */
+  "local"
+];
+var BEMONY_DEFAULT_BROWSER_ENVIRONMENT = "production";
+var BEMONY_DEFAULT_BROWSER_SCENARIO = "offer-page";
+var BEMONY_BROWSER_AUTO_INIT_DEFAULTS = Object.freeze({
+  environment: BEMONY_DEFAULT_BROWSER_ENVIRONMENT,
+  scenario: BEMONY_DEFAULT_BROWSER_SCENARIO,
+  platform: Object.freeze({
+    pixelId: BEMONY_DEFAULT_PIXEL_ID,
+    apiEndpoint: BEMONY_DEFAULT_API_ENDPOINT,
+    namespace: BEMONY_DEFAULT_NAMESPACE,
+    allowedDomains: Object.freeze([...BEMONY_DEFAULT_ALLOWED_DOMAINS])
+  })
+});
+var BEMONY_PLATFORM_DEFAULTS = {
+  app: {
+    source: "bemony"
+  },
+  storage: {
+    prefix: BEMONY_STORAGE_PREFIX,
+    namespace: BEMONY_DEFAULT_NAMESPACE,
+    persistence: {
+      visitor: "localStorage",
+      session: "sessionStorage",
+      attribution: "localStorage"
+    }
+  },
+  attribution: {
+    enabled: true,
+    persist: true,
+    captureUrlParams: true,
+    captureCookies: true
+  }
+};
+function applyBemonyPlatformDefaults(base, platform) {
+  const namespace = platform.namespace ?? BEMONY_DEFAULT_NAMESPACE;
+  return {
+    ...base,
+    app: {
+      ...base.app,
+      source: BEMONY_PLATFORM_DEFAULTS.app.source
+    },
+    identity: {
+      ...base.identity,
+      pixelId: platform.pixelId
+    },
+    storage: {
+      ...base.storage,
+      prefix: BEMONY_PLATFORM_DEFAULTS.storage.prefix,
+      namespace,
+      persistence: {
+        ...base.storage.persistence,
+        ...BEMONY_PLATFORM_DEFAULTS.storage.persistence
+      }
+    },
+    attribution: {
+      ...base.attribution,
+      ...BEMONY_PLATFORM_DEFAULTS.attribution,
+      customClickIdParams: base.attribution.customClickIdParams ? [...base.attribution.customClickIdParams] : []
+    }
+  };
+}
+
+// src/navigation/BemonyLinkPolicy.ts
+var DEFAULT_BEMONY_LINK_SELECTOR = "[data-bemony-offer][href]";
+function normalizeAllowedDomain(domain) {
+  let value = domain.trim().toLowerCase();
+  value = value.replace(/^https?:\/\//, "");
+  value = value.split("/")[0] ?? value;
+  value = value.split("?")[0] ?? value;
+  value = value.split("#")[0] ?? value;
+  const withoutPort = value.replace(/:\d+$/, "");
+  return withoutPort;
+}
+function normalizeAllowedDomains(domains) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const raw of domains) {
+    const normalized = normalizeAllowedDomain(raw);
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+function createBemonyLinkPolicy(options = {}) {
+  const sourceDomains = options.allowedDomains !== void 0 && options.allowedDomains.length > 0 ? options.allowedDomains : BEMONY_DEFAULT_ALLOWED_DOMAINS;
+  const allowedDomains = normalizeAllowedDomains([...sourceDomains]);
+  const selector = options.selector?.trim();
+  return {
+    allowedDomains,
+    ...selector ? { selector } : {},
+    strategy: options.strategy ?? "both",
+    preserveExisting: options.preserveExisting ?? true,
+    overwriteExisting: options.overwriteExisting ?? false,
+    decorateMailto: false,
+    decorateTel: false,
+    decorateHashLinks: false,
+    mergeDefaultExcludedDomains: true,
+    mergeDefaultExcludeSelectors: true,
+    excludeSelectors: options.excludeSelectors ? [...options.excludeSelectors] : void 0
+  };
+}
+function linkPolicyToDecorationConfig(policy) {
+  return {
+    enabled: true,
+    strategy: policy.strategy,
+    allowedDomains: [...policy.allowedDomains],
+    ...policy.selector ? { selector: policy.selector } : {},
+    preserveExisting: policy.preserveExisting,
+    overwriteExisting: policy.overwriteExisting,
+    decorateMailto: policy.decorateMailto,
+    decorateTel: policy.decorateTel,
+    decorateHashLinks: policy.decorateHashLinks,
+    mergeDefaultExcludedDomains: policy.mergeDefaultExcludedDomains,
+    mergeDefaultExcludeSelectors: policy.mergeDefaultExcludeSelectors,
+    ...policy.excludeSelectors ? { excludeSelectors: [...policy.excludeSelectors] } : {}
+  };
+}
+
+// src/navigation/configureBemonyLinks.ts
+var BEMONY_SID_MANAGED_PARAM = {
+  key: "public_session",
+  param: "sid",
+  mode: "read_write",
+  writeStrategy: "replaceState",
+  generator: { type: "public_id", prefix: "sid" },
+  persistence: {
+    enabled: true,
+    strategy: "localStorage_cookie",
+    storageKey: "sid"
+  },
+  decorateLinks: true
+};
+var BEMONY_AFID_MANAGED_PARAM = {
+  key: "affiliate",
+  param: "afid",
+  mode: "read_write",
+  writeStrategy: "replaceState",
+  persistence: {
+    enabled: true,
+    strategy: "localStorage_cookie",
+    storageKey: "afid"
+  },
+  decorateLinks: true
+};
+var BEMONY_OID_MANAGED_PARAM = {
+  key: "order_id",
+  param: "oid",
+  mode: "read_write",
+  writeStrategy: "replaceState",
+  persistence: {
+    enabled: true,
+    strategy: "localStorage_cookie",
+    storageKey: "oid"
+  },
+  decorateLinks: true
+};
+var BEMONY_FID_MANAGED_PARAM = {
+  key: "funnel_id",
+  param: "fid",
+  mode: "read_write",
+  writeStrategy: "replaceState",
+  persistence: {
+    enabled: true,
+    strategy: "localStorage_cookie",
+    storageKey: "fid"
+  },
+  decorateLinks: true
+};
+var BEMONY_FSID_MANAGED_PARAM = {
+  key: "funnel_step_id",
+  param: "fsid",
+  mode: "read_write",
+  writeStrategy: "replaceState",
+  persistence: {
+    enabled: true,
+    strategy: "localStorage_cookie",
+    storageKey: "fsid"
+  },
+  decorateLinks: true
+};
+var BEMONY_FORWARD_DENYLIST = [
+  "token",
+  "one_click_token",
+  "oneclicktoken",
+  "oneClickToken",
+  "ephemeral_token",
+  "payment_token",
+  "access_token",
+  "refresh_token",
+  "id_token",
+  "auth_token",
+  "secret",
+  "password",
+  "pass",
+  "pwd",
+  "email",
+  "phone",
+  "cpf",
+  "cnpj",
+  "document",
+  "card",
+  "cc",
+  "credit_card",
+  "pan",
+  "cvv",
+  "cvc",
+  "auth",
+  "code",
+  "sessionid",
+  "internalsessionid",
+  "pixelsessionid"
+];
+function cloneManagedParam(param) {
+  return {
+    ...param,
+    ...param.generator ? { generator: { ...param.generator } } : {},
+    ...param.persistence ? {
+      persistence: {
+        ...param.persistence,
+        ...param.persistence.cookie ? { cookie: { ...param.persistence.cookie } } : {}
+      }
+    } : {}
+  };
+}
+function configureBemonyLinks(options = {}) {
+  const policy = createBemonyLinkPolicy(options);
+  const includeSid = options.includeSidManagedParam !== false;
+  const includeAfid = options.includeAfidManagedParam !== false;
+  const includeOid = options.includeOidManagedParam !== false;
+  const includeFunnel = options.includeFunnelManagedParams !== false;
+  const managedParams = [];
+  if (includeSid) {
+    managedParams.push(cloneManagedParam(BEMONY_SID_MANAGED_PARAM));
+  }
+  if (includeAfid) {
+    managedParams.push(cloneManagedParam(BEMONY_AFID_MANAGED_PARAM));
+  }
+  if (includeOid) {
+    managedParams.push(cloneManagedParam(BEMONY_OID_MANAGED_PARAM));
+  }
+  if (includeFunnel) {
+    managedParams.push(cloneManagedParam(BEMONY_FID_MANAGED_PARAM));
+    managedParams.push(cloneManagedParam(BEMONY_FSID_MANAGED_PARAM));
+  }
+  const denylist = [...BEMONY_FORWARD_DENYLIST];
+  return {
+    enabled: true,
+    queryParams: {
+      enabled: true,
+      mode: "all_except",
+      mergeDefaultDenylist: true,
+      denylist: [...denylist]
+    },
+    managedParams,
+    forwardParams: {
+      enabled: true,
+      mode: "all_except",
+      mergeDefaultDenylist: true,
+      denylist: [...denylist]
+    },
+    linkDecoration: linkPolicyToDecorationConfig(policy)
+  };
+}
+
+// src/platform/environments.ts
+var BEMONY_ENVIRONMENTS = [
+  "development",
+  "staging",
+  "production"
+];
+function isNonEmptyEndpoint(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function resolveBemonyEnvironment(options) {
+  const { environment } = options;
+  if (environment === "development") {
+    return {
+      environment,
+      debug: options.debugOverride ?? true,
+      apiEndpoint: isNonEmptyEndpoint(options.apiEndpoint) ? options.apiEndpoint.trim() : "",
+      transportEnabled: false,
+      senderMode: "mock"
+    };
+  }
+  if (environment === "staging" || environment === "production") {
+    if (!isNonEmptyEndpoint(options.apiEndpoint)) {
+      throw new BemonyValidationError({
+        code: "MISSING_ENDPOINT",
+        field: "apiEndpoint",
+        message: `apiEndpoint is required for environment "${environment}". Inject an approved endpoint; do not hardcode credentials.`
+      });
+    }
+    return {
+      environment,
+      debug: options.debugOverride ?? false,
+      apiEndpoint: options.apiEndpoint.trim(),
+      transportEnabled: true,
+      senderMode: "http"
+    };
+  }
+  throw new BemonyValidationError({
+    code: "INVALID_ENVIRONMENT",
+    field: "environment",
+    message: "Unsupported Bemony environment."
+  });
+}
+function applyBemonyEnvironment(base, resolution) {
+  return {
+    ...base,
+    app: {
+      ...base.app,
+      environment: resolution.environment,
+      debug: resolution.debug
+    },
+    transport: {
+      ...base.transport,
+      apiEndpoint: resolution.apiEndpoint
+    },
+    modules: {
+      ...base.modules,
+      transport: {
+        ...base.modules.transport,
+        enabled: resolution.transportEnabled,
+        sender: {
+          ...base.modules.transport.sender,
+          mode: resolution.senderMode
+        },
+        mockSender: {
+          ...base.modules.transport.mockSender,
+          enabled: resolution.senderMode === "mock"
+        }
+      }
+    }
+  };
+}
+
+// src/scenarios/checkout.ts
+function resolveMainProductId(products) {
+  if (!products || products.length === 0) {
+    return void 0;
+  }
+  const main = products.find((product) => product.type === "main");
+  return (main ?? products[0])?.id;
+}
+function applyCheckoutScenario(base, options = {
+  autoInitiateCheckout: true,
+  includeOidManagedParam: true
+}) {
+  const products = (options.products ?? []).map((product) => ({ ...product }));
+  const currency = options.currency ?? base.commerce.currency ?? "BRL";
+  const mainProductId = resolveMainProductId(products);
+  const autoInitiateCheckout = options.autoInitiateCheckout !== false;
+  const allowedDomains = normalizeAllowedDomains(
+    options.allowedDomains !== void 0 && options.allowedDomains.length > 0 ? [...options.allowedDomains] : [...BEMONY_DEFAULT_ALLOWED_DOMAINS]
+  );
+  const urlContext = configureBemonyLinks({
+    allowedDomains,
+    includeOidManagedParam: options.includeOidManagedParam ?? true
+  });
+  const conversionManual = {
+    ...base.modules.conversion.manual,
+    lead: { enabled: true },
+    addToCart: { enabled: true },
+    removeFromCart: { enabled: true },
+    initiateCheckout: { enabled: true },
+    addPaymentInfo: { enabled: true },
+    viewContent: { enabled: false },
+    pageView: { enabled: false },
+    purchase: { enabled: false },
+    search: { enabled: false }
+  };
+  return {
+    ...base,
+    app: {
+      ...base.app,
+      target: "checkout",
+      source: "bemony"
+    },
+    commerce: {
+      ...base.commerce,
+      enabled: true,
+      currency,
+      catalog: { products },
+      cart: {
+        ...base.commerce.cart,
+        mode: "checkout",
+        initialItems: mainProductId ? [{ productId: mainProductId, quantity: 1 }] : [],
+        allowDynamicItems: true,
+        calculateValueFrom: "cart"
+      },
+      mappings: {
+        attributes: { ...base.commerce.mappings?.attributes ?? {} },
+        fields: { ...base.commerce.mappings?.fields ?? {} }
+      },
+      enrichment: {
+        ...base.commerce.enrichment ?? {},
+        initiateCheckout: { enabled: true, source: "cart" },
+        lead: { enabled: false, source: "event_or_cart" },
+        addToCart: { enabled: true, source: "event_or_cart" },
+        removeFromCart: { enabled: true, source: "event_or_cart" },
+        addPaymentInfo: { enabled: true, source: "cart" },
+        purchase: { enabled: false, source: "cart" },
+        viewContent: { enabled: false, source: "event_or_cart" },
+        pageView: { enabled: false, source: "cart" }
+      }
+    },
+    modules: {
+      ...base.modules,
+      core: {
+        ...base.modules.core,
+        enabled: true,
+        pageView: {
+          ...base.modules.core.pageView,
+          enabled: true,
+          trackInitialPageView: true
+        },
+        urlContext
+      },
+      conversion: {
+        ...base.modules.conversion,
+        enabled: true,
+        manual: conversionManual,
+        auto: {
+          enabled: true,
+          detectors: {
+            ...base.modules.conversion.auto.detectors,
+            addToCart: {
+              enabled: true,
+              sources: [
+                {
+                  name: "main-product-after-contact",
+                  type: "form",
+                  selectorForm: {
+                    fields: ["email", "phone"],
+                    mode: "all",
+                    formSelector: "#checkout-form",
+                    trigger: "input",
+                    debounceMs: 300,
+                    fireOnce: true
+                  }
+                },
+                {
+                  name: "product-or-bump-click",
+                  type: "selector",
+                  selector: "add_to_cart",
+                  selectorType: "attribute",
+                  trigger: "click",
+                  fireOnce: false
+                }
+              ]
+            },
+            removeFromCart: {
+              enabled: true,
+              sources: [
+                {
+                  name: "remove-product-click",
+                  type: "selector",
+                  selector: "remove_from_cart",
+                  selectorType: "attribute",
+                  trigger: "click"
+                }
+              ]
+            },
+            initiateCheckout: {
+              enabled: autoInitiateCheckout,
+              sources: autoInitiateCheckout ? [
+                {
+                  name: "checkout-loaded",
+                  type: "lifecycle",
+                  trigger: "ready",
+                  fireOnce: true
+                }
+              ] : []
+            },
+            addPaymentInfo: {
+              enabled: true,
+              sources: [
+                {
+                  name: "credit-card-detection",
+                  type: "payment",
+                  paymentMethod: "CREDIT_CARD",
+                  cardDetection: true,
+                  autoDispatch: true,
+                  formSelector: "#checkout-form",
+                  fireOnce: true
+                },
+                {
+                  name: "payment-button-click",
+                  type: "selector",
+                  selector: '[data-track="add_payment_info"]',
+                  selectorType: "css",
+                  trigger: "click",
+                  fireOnce: false
+                }
+              ]
+            }
+          }
+        }
+      },
+      behavior: {
+        ...base.modules.behavior,
+        enabled: false
+      }
+    }
+  };
+}
+
+// src/scenarios/one-click-checkout.ts
+function resolveCartMode(products) {
+  const list = products ?? [];
+  const isUpsellLike = list.some(
+    (product) => product.type === "upsell" || product.type === "downsell"
+  );
+  return isUpsellLike ? "upsell" : "checkout";
+}
+function resolvePrimaryProductId(products) {
+  if (!products || products.length === 0) {
+    return void 0;
+  }
+  const preferred = products.find(
+    (product) => product.type === "upsell" || product.type === "downsell" || product.type === "main"
+  );
+  return (preferred ?? products[0])?.id;
+}
+function applyOneClickCheckoutScenario(base, options = {}) {
+  const products = (options.products ?? []).map((product) => ({ ...product }));
+  const currency = options.currency ?? base.commerce.currency ?? "BRL";
+  const cartMode = resolveCartMode(products);
+  const primaryId = resolvePrimaryProductId(products);
+  const urlContext = configureBemonyLinks({
+    allowedDomains: options.allowedDomains ? [...options.allowedDomains] : [],
+    includeOidManagedParam: true
+  });
+  const conversionManual = {
+    ...base.modules.conversion.manual,
+    initiateCheckout: { enabled: true },
+    addToCart: { enabled: true },
+    viewContent: { enabled: false },
+    lead: { enabled: false },
+    removeFromCart: { enabled: false },
+    addPaymentInfo: { enabled: false },
+    pageView: { enabled: false },
+    purchase: { enabled: false },
+    search: { enabled: false }
+  };
+  return {
+    ...base,
+    app: {
+      ...base.app,
+      target: "checkout"
+    },
+    commerce: {
+      ...base.commerce,
+      enabled: true,
+      currency,
+      catalog: { products },
+      cart: {
+        ...base.commerce.cart,
+        mode: cartMode,
+        initialItems: primaryId ? [{ productId: primaryId, quantity: 1 }] : [],
+        allowDynamicItems: true,
+        calculateValueFrom: "cart"
+      },
+      mappings: {
+        attributes: { ...base.commerce.mappings?.attributes ?? {} },
+        fields: { ...base.commerce.mappings?.fields ?? {} }
+      },
+      enrichment: {
+        ...base.commerce.enrichment ?? {},
+        initiateCheckout: { enabled: true, source: "cart" },
+        addToCart: { enabled: true, source: "event_or_cart" },
+        purchase: { enabled: false, source: "cart" },
+        lead: { enabled: false, source: "event_or_cart" },
+        viewContent: { enabled: false, source: "event_or_cart" },
+        pageView: { enabled: false, source: "cart" }
+      }
+    },
+    modules: {
+      ...base.modules,
+      core: {
+        ...base.modules.core,
+        enabled: true,
+        pageView: {
+          ...base.modules.core.pageView,
+          enabled: true,
+          trackInitialPageView: true
+        },
+        urlContext
+      },
+      conversion: {
+        ...base.modules.conversion,
+        enabled: true,
+        manual: conversionManual,
+        auto: {
+          ...base.modules.conversion.auto,
+          enabled: false
+        }
+      },
+      behavior: {
+        ...base.modules.behavior,
+        enabled: false
+      }
+    }
+  };
+}
+
+// src/navigation/createBemonyOfferLinkSource.ts
+function createBemonyOfferLinkSource(allowedDomains) {
+  const hostnames = normalizeAllowedDomains([...allowedDomains]).filter(
+    (host) => host !== "local"
+  );
+  return {
+    name: "bemony-offer-link",
+    type: "link",
+    enabled: true,
+    trigger: "click",
+    fireOnce: false,
+    match: {
+      protocols: ["https:", "http:"],
+      hostnames,
+      path: {
+        segmentPrefixes: ["pri"]
+      }
+    },
+    bindings: {
+      // Core LinkAuto reconhece priceCode; productId no evento = priceCode observado.
+      priceCode: {
+        from: {
+          source: "pathSegment",
+          index: -1
+        },
+        required: true
+      }
+    }
+  };
+}
+
+// src/scenarios/offer-page.ts
+function applyOfferPageScenario(base, options = {}) {
+  const cartMode = options.cartMode ?? "landing_page";
+  const products = (options.products ?? []).map((product) => ({ ...product }));
+  const currency = options.currency ?? base.commerce.currency ?? "BRL";
+  const allowedDomains = normalizeAllowedDomains(
+    options.allowedDomains !== void 0 && options.allowedDomains.length > 0 ? [...options.allowedDomains] : [...BEMONY_DEFAULT_ALLOWED_DOMAINS]
+  );
+  const urlContext = configureBemonyLinks({ allowedDomains });
+  const offerLinkSource = createBemonyOfferLinkSource(allowedDomains);
+  const conversionManual = {
+    ...base.modules.conversion.manual,
+    viewContent: { enabled: true },
+    addToCart: { enabled: true },
+    // Offer page não emite estes manualmente nesta etapa.
+    pageView: { enabled: false },
+    purchase: { enabled: false },
+    lead: { enabled: false },
+    removeFromCart: { enabled: false },
+    initiateCheckout: { enabled: false },
+    addPaymentInfo: { enabled: false },
+    search: { enabled: false }
+  };
+  return {
+    ...base,
+    app: {
+      ...base.app,
+      target: "landing"
+    },
+    commerce: {
+      ...base.commerce,
+      enabled: true,
+      currency,
+      catalog: { products },
+      cart: {
+        ...base.commerce.cart,
+        mode: cartMode,
+        initialItems: base.commerce.cart?.initialItems ? base.commerce.cart.initialItems.map((item) => ({ ...item })) : [],
+        allowDynamicItems: true,
+        calculateValueFrom: "cart"
+      },
+      mappings: {
+        attributes: { ...base.commerce.mappings?.attributes ?? {} },
+        fields: { ...base.commerce.mappings?.fields ?? {} }
+      },
+      enrichment: {
+        ...base.commerce.enrichment ?? {},
+        viewContent: { enabled: true, source: "event_or_cart" },
+        addToCart: { enabled: true, source: "event_or_cart" },
+        pageView: { enabled: false, source: "cart" },
+        purchase: { enabled: false, source: "cart" },
+        lead: { enabled: false, source: "event_or_cart" }
+      }
+    },
+    modules: {
+      ...base.modules,
+      core: {
+        ...base.modules.core,
+        enabled: true,
+        pageView: {
+          ...base.modules.core.pageView,
+          enabled: true,
+          trackInitialPageView: true
+        },
+        urlContext
+      },
+      conversion: {
+        ...base.modules.conversion,
+        enabled: true,
+        manual: conversionManual,
+        auto: {
+          ...base.modules.conversion.auto,
+          enabled: true,
+          detectors: {
+            ...base.modules.conversion.auto.detectors,
+            addToCart: {
+              enabled: true,
+              sources: [offerLinkSource]
+            }
+          }
+        }
+      },
+      behavior: {
+        ...base.modules.behavior,
+        enabled: false
+      }
+    }
+  };
+}
+
+// src/scenarios/thank-you.ts
+function applyThankYouScenario(base, options = {}) {
+  const currency = options.currency ?? base.commerce.currency ?? "BRL";
+  const urlContext = configureBemonyLinks({
+    allowedDomains: options.allowedDomains ? [...options.allowedDomains] : [],
+    includeOidManagedParam: true
+  });
+  const conversionManual = {
+    ...base.modules.conversion.manual,
+    pageView: { enabled: false },
+    purchase: { enabled: false },
+    lead: { enabled: false },
+    addToCart: { enabled: false },
+    removeFromCart: { enabled: false },
+    initiateCheckout: { enabled: false },
+    addPaymentInfo: { enabled: false },
+    search: { enabled: false },
+    viewContent: { enabled: false }
+  };
+  return {
+    ...base,
+    app: {
+      ...base.app,
+      target: "custom"
+    },
+    commerce: {
+      ...base.commerce,
+      enabled: false,
+      currency,
+      catalog: { products: [] },
+      cart: {
+        ...base.commerce.cart,
+        mode: "custom",
+        initialItems: [],
+        allowDynamicItems: false,
+        calculateValueFrom: "cart"
+      },
+      enrichment: {
+        ...base.commerce.enrichment ?? {},
+        purchase: { enabled: false, source: "cart" },
+        pageView: { enabled: false, source: "cart" }
+      }
+    },
+    modules: {
+      ...base.modules,
+      core: {
+        ...base.modules.core,
+        enabled: true,
+        pageView: {
+          ...base.modules.core.pageView,
+          enabled: true,
+          trackInitialPageView: true
+        },
+        urlContext
+      },
+      conversion: {
+        ...base.modules.conversion,
+        enabled: false,
+        manual: conversionManual,
+        auto: {
+          ...base.modules.conversion.auto,
+          enabled: false
+        }
+      },
+      behavior: {
+        ...base.modules.behavior,
+        enabled: false
+      }
+    }
+  };
+}
+
+// src/scenarios/upsell-offer.ts
+var BEMONY_UPSELL_BUY_LINK_SELECTOR = 'a[href*="pri"], [data-bemony-offer][href]';
+var BEMONY_UPSELL_LINK_SELECTOR = BEMONY_UPSELL_BUY_LINK_SELECTOR;
+function escapeCssAttributeValue(value) {
+  if (typeof CSS !== "undefined" && typeof CSS.escape === "function") {
+    return CSS.escape(value);
+  }
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function buildUpsellLinkSelector(noThanksUrl) {
+  const raw = noThanksUrl?.trim();
+  if (!raw) {
+    return BEMONY_UPSELL_BUY_LINK_SELECTOR;
+  }
+  return `${BEMONY_UPSELL_BUY_LINK_SELECTOR}, a[href="${escapeCssAttributeValue(raw)}"]`;
+}
+function hrefMatchesNoThanksUrl(href, noThanksUrl, baseHref) {
+  const linkHref = href?.trim();
+  const targetRaw = noThanksUrl.trim();
+  if (!linkHref || linkHref === "#" || !targetRaw) {
+    return false;
+  }
+  if (linkHref === targetRaw) {
+    return true;
+  }
+  try {
+    const base = baseHref ?? (typeof window !== "undefined" && window.location?.href ? window.location.href : "https://localhost/");
+    const left = new URL(linkHref, base);
+    const right = new URL(targetRaw, base);
+    left.hash = "";
+    right.hash = "";
+    return left.href === right.href;
+  } catch {
+    return false;
+  }
+}
+function applyUpsellOfferScenario(base, options = {}) {
+  const products = (options.products ?? []).map((product) => ({ ...product }));
+  const currency = options.currency ?? base.commerce.currency ?? "BRL";
+  const allowedDomains = normalizeAllowedDomains(
+    options.allowedDomains !== void 0 && options.allowedDomains.length > 0 ? [...options.allowedDomains] : [...BEMONY_DEFAULT_ALLOWED_DOMAINS]
+  );
+  const urlContext = configureBemonyLinks({
+    allowedDomains,
+    selector: buildUpsellLinkSelector(options.noThanksUrl),
+    includeOidManagedParam: options.includeOidManagedParam ?? true
+  });
+  const offerLinkSource = createBemonyOfferLinkSource(allowedDomains);
+  const conversionManual = {
+    ...base.modules.conversion.manual,
+    viewContent: { enabled: true },
+    addToCart: { enabled: true },
+    pageView: { enabled: false },
+    purchase: { enabled: false },
+    lead: { enabled: false },
+    removeFromCart: { enabled: false },
+    initiateCheckout: { enabled: false },
+    addPaymentInfo: { enabled: false },
+    search: { enabled: false }
+  };
+  return {
+    ...base,
+    app: {
+      ...base.app,
+      target: "custom"
+    },
+    commerce: {
+      ...base.commerce,
+      enabled: true,
+      currency,
+      catalog: { products },
+      cart: {
+        ...base.commerce.cart,
+        mode: "upsell",
+        initialItems: [],
+        allowDynamicItems: true,
+        calculateValueFrom: "cart"
+      },
+      mappings: {
+        attributes: { ...base.commerce.mappings?.attributes ?? {} },
+        fields: { ...base.commerce.mappings?.fields ?? {} }
+      },
+      enrichment: {
+        ...base.commerce.enrichment ?? {},
+        viewContent: { enabled: true, source: "event_or_cart" },
+        addToCart: { enabled: true, source: "event_or_cart" },
+        pageView: { enabled: false, source: "cart" },
+        purchase: { enabled: false, source: "cart" },
+        lead: { enabled: false, source: "event_or_cart" },
+        initiateCheckout: { enabled: false, source: "cart" }
+      }
+    },
+    modules: {
+      ...base.modules,
+      core: {
+        ...base.modules.core,
+        enabled: true,
+        pageView: {
+          ...base.modules.core.pageView,
+          enabled: true,
+          trackInitialPageView: true
+        },
+        urlContext
+      },
+      conversion: {
+        ...base.modules.conversion,
+        enabled: true,
+        manual: conversionManual,
+        auto: {
+          ...base.modules.conversion.auto,
+          enabled: true,
+          detectors: {
+            ...base.modules.conversion.auto.detectors,
+            addToCart: {
+              enabled: true,
+              sources: [offerLinkSource]
+            }
+          }
+        }
+      },
+      behavior: {
+        ...base.modules.behavior,
+        enabled: false
+      }
+    }
+  };
+}
+
+// src/createBemonyPixelConfig.ts
+var SCENARIO_TARGET = {
+  "offer-page": "landing",
+  checkout: "checkout",
+  "upsell-offer": "custom",
+  "one-click-checkout": "checkout",
+  "thank-you": "custom"
+};
+var SCENARIO_CART_MODE = {
+  "offer-page": "landing_page",
+  checkout: "checkout",
+  "upsell-offer": "upsell",
+  "one-click-checkout": "checkout",
+  "thank-you": "custom"
+};
+var PRODUCT_TYPES = /* @__PURE__ */ new Set([
+  "main",
+  "order_bump",
+  "upsell",
+  "downsell",
+  "cross_sell",
+  "addon",
+  "subscription",
+  "custom",
+  "other"
+]);
+function cloneProducts(products) {
+  if (!products) {
+    return [];
+  }
+  return products.map((product) => {
+    const type = product.type && PRODUCT_TYPES.has(product.type) ? product.type : void 0;
+    return {
+      id: product.id,
+      ...product.name !== void 0 ? { name: product.name } : {},
+      ...type !== void 0 ? { type } : {},
+      ...product.price !== void 0 ? { price: product.price } : {},
+      ...product.currency !== void 0 ? { currency: product.currency } : {},
+      ...product.quantity !== void 0 ? { quantity: product.quantity } : {}
+    };
+  });
+}
+function resolveOfferPageCartMode(commerce) {
+  if (commerce?.cartMode === "single_product") {
+    return "single_product";
+  }
+  return "landing_page";
+}
+function mapPublicContextToIdentity(base, publicContext) {
+  return {
+    ...base,
+    ...publicContext.pageId !== void 0 ? { pageId: publicContext.pageId } : {},
+    ...publicContext.funnelId !== void 0 ? { funnelId: publicContext.funnelId } : {},
+    ...publicContext.funnelStepId !== void 0 ? { funnelStepId: publicContext.funnelStepId } : {},
+    ...publicContext.offerId !== void 0 ? { offerId: publicContext.offerId } : {},
+    ...publicContext.affiliateId !== void 0 ? { affiliateId: publicContext.affiliateId } : {},
+    ...publicContext.checkoutId !== void 0 ? { checkoutId: publicContext.checkoutId } : {}
+  };
+}
+function applyMinimalScenarioPreset(base, scenario, commerce, allowedDomains) {
+  const products = cloneProducts(commerce?.products);
+  const currency = commerce?.currency ?? base.commerce.currency ?? "BRL";
+  const urlContext = configureBemonyLinks({
+    allowedDomains: allowedDomains ? [...allowedDomains] : []
+  });
+  return {
+    ...base,
+    app: {
+      ...base.app,
+      target: SCENARIO_TARGET[scenario],
+      debug: true
+    },
+    commerce: {
+      ...base.commerce,
+      enabled: true,
+      currency,
+      catalog: {
+        products
+      },
+      cart: {
+        ...base.commerce.cart,
+        mode: SCENARIO_CART_MODE[scenario],
+        initialItems: base.commerce.cart?.initialItems ? base.commerce.cart.initialItems.map((item) => ({ ...item })) : [],
+        allowDynamicItems: true,
+        calculateValueFrom: "cart"
+      },
+      mappings: {
+        attributes: { ...base.commerce.mappings?.attributes ?? {} },
+        fields: { ...base.commerce.mappings?.fields ?? {} }
+      },
+      enrichment: {
+        ...base.commerce.enrichment ?? {}
+      }
+    },
+    modules: {
+      ...base.modules,
+      core: {
+        ...base.modules.core,
+        urlContext
+      },
+      conversion: {
+        ...base.modules.conversion,
+        enabled: false
+      },
+      behavior: {
+        ...base.modules.behavior,
+        enabled: false
+      }
+    }
+  };
+}
+function applyScenarioPreset(base, scenario, commerce, allowedDomains, autoInitiateCheckout, noThanksUrl) {
+  if (scenario === "offer-page") {
+    return applyOfferPageScenario(base, {
+      allowedDomains,
+      currency: commerce?.currency,
+      cartMode: resolveOfferPageCartMode(commerce),
+      products: cloneProducts(commerce?.products)
+    });
+  }
+  if (scenario === "checkout") {
+    return applyCheckoutScenario(base, {
+      allowedDomains,
+      currency: commerce?.currency,
+      products: cloneProducts(commerce?.products),
+      autoInitiateCheckout
+    });
+  }
+  if (scenario === "upsell-offer") {
+    return applyUpsellOfferScenario(base, {
+      allowedDomains,
+      currency: commerce?.currency,
+      products: cloneProducts(commerce?.products),
+      ...noThanksUrl ? { noThanksUrl } : {}
+    });
+  }
+  if (scenario === "one-click-checkout") {
+    return applyOneClickCheckoutScenario(base, {
+      allowedDomains,
+      currency: commerce?.currency,
+      products: cloneProducts(commerce?.products)
+    });
+  }
+  if (scenario === "thank-you") {
+    return applyThankYouScenario(base, {
+      allowedDomains,
+      currency: commerce?.currency
+    });
+  }
+  return applyMinimalScenarioPreset(base, scenario, commerce, allowedDomains);
+}
+function createBemonyPixelConfig(options) {
+  const pageInput = normalizeBemonyPageContextInput(options.page);
+  const resolvedPublic = resolveBemonyPageContext({
+    input: pageInput.public,
+    urlParams: options.urlParams,
+    pageMetadata: options.pageMetadata,
+    scenarioDefaults: options.scenarioDefaults
+  });
+  const validatedPublic = validateBemonyPageContext({
+    scenario: options.scenario,
+    publicContext: resolvedPublic
+  });
+  const apiEndpoint = options.overrides?.apiEndpoint ?? options.platform.apiEndpoint;
+  const debugOverride = options.overrides?.debug ?? options.platform.debug;
+  const allowedDomains = options.overrides?.allowedDomains ?? options.platform.allowedDomains;
+  const envResolution = resolveBemonyEnvironment({
+    environment: options.environment,
+    apiEndpoint,
+    debugOverride
+  });
+  let config = {
+    ...DEFAULT_PIXEL_CONFIG,
+    app: { ...DEFAULT_PIXEL_CONFIG.app },
+    identity: { ...DEFAULT_PIXEL_CONFIG.identity },
+    transport: { ...DEFAULT_PIXEL_CONFIG.transport },
+    storage: {
+      ...DEFAULT_PIXEL_CONFIG.storage,
+      queue: DEFAULT_PIXEL_CONFIG.storage.queue ? { ...DEFAULT_PIXEL_CONFIG.storage.queue } : void 0,
+      keys: DEFAULT_PIXEL_CONFIG.storage.keys ? { ...DEFAULT_PIXEL_CONFIG.storage.keys } : void 0,
+      persistence: DEFAULT_PIXEL_CONFIG.storage.persistence ? { ...DEFAULT_PIXEL_CONFIG.storage.persistence } : void 0
+    },
+    attribution: {
+      ...DEFAULT_PIXEL_CONFIG.attribution,
+      customClickIdParams: DEFAULT_PIXEL_CONFIG.attribution.customClickIdParams ? [...DEFAULT_PIXEL_CONFIG.attribution.customClickIdParams] : []
+    },
+    commerce: {
+      ...DEFAULT_PIXEL_CONFIG.commerce,
+      catalog: {
+        products: DEFAULT_PIXEL_CONFIG.commerce.catalog?.products ? DEFAULT_PIXEL_CONFIG.commerce.catalog.products.map((p) => ({
+          ...p
+        })) : []
+      },
+      cart: {
+        ...DEFAULT_PIXEL_CONFIG.commerce.cart,
+        initialItems: DEFAULT_PIXEL_CONFIG.commerce.cart?.initialItems ? DEFAULT_PIXEL_CONFIG.commerce.cart.initialItems.map((i) => ({
+          ...i
+        })) : []
+      },
+      mappings: {
+        attributes: {
+          ...DEFAULT_PIXEL_CONFIG.commerce.mappings?.attributes ?? {}
+        },
+        fields: { ...DEFAULT_PIXEL_CONFIG.commerce.mappings?.fields ?? {} }
+      },
+      enrichment: { ...DEFAULT_PIXEL_CONFIG.commerce.enrichment ?? {} }
+    },
+    modules: {
+      core: { ...DEFAULT_PIXEL_CONFIG.modules.core },
+      behavior: { ...DEFAULT_PIXEL_CONFIG.modules.behavior },
+      conversion: { ...DEFAULT_PIXEL_CONFIG.modules.conversion },
+      transport: {
+        ...DEFAULT_PIXEL_CONFIG.modules.transport,
+        sender: { ...DEFAULT_PIXEL_CONFIG.modules.transport.sender },
+        mockSender: { ...DEFAULT_PIXEL_CONFIG.modules.transport.mockSender }
+      },
+      integrations: { ...DEFAULT_PIXEL_CONFIG.modules.integrations },
+      privacy: { ...DEFAULT_PIXEL_CONFIG.modules.privacy }
+    }
+  };
+  config = applyBemonyPlatformDefaults(config, options.platform);
+  config = applyBemonyEnvironment(config, envResolution);
+  config = applyScenarioPreset(
+    config,
+    options.scenario,
+    options.commerce,
+    allowedDomains,
+    options.autoInitiateCheckout,
+    options.noThanksUrl
+  );
+  config = {
+    ...config,
+    identity: mapPublicContextToIdentity(config.identity, validatedPublic)
+  };
+  return config;
+}
+
+// src/createBemonyPixel.ts
+import { prepareJourneyUrlContext } from "@beworke/pixel";
+import {
+  createStorageAdapter,
+  StorageServiceImpl
+} from "@beworke/pixel/services";
+
+// src/BemonyPixel.ts
+import {
+  Pixel
+} from "@beworke/pixel";
+
+// src/domain/BemonyLeadInput.ts
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var BLOCKED_FIELD_KEY = /^(card|cvv|cvc|pan|number|expiry|expiration|password|token|cvv2)/i;
+function isValidBemonyLead(input) {
+  const email = input.email?.trim();
+  const phone = input.phone?.trim();
+  const emailOk = Boolean(email && EMAIL_PATTERN.test(email));
+  const phoneDigits = phone ? phone.replace(/\D/g, "") : "";
+  const phoneOk = phoneDigits.length >= 8;
+  return emailOk || phoneOk;
+}
+function leadFingerprint(input) {
+  const email = input.email?.trim().toLowerCase() ?? "";
+  const phone = input.phone?.replace(/\D/g, "") ?? "";
+  const name = input.name?.trim().toLowerCase() ?? "";
+  return `${email}|${phone}|${name}`;
+}
+function sanitizeLeadFields(fields) {
+  if (!fields) {
+    return void 0;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(fields)) {
+    if (BLOCKED_FIELD_KEY.test(key)) {
+      continue;
+    }
+    result[key] = value;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+
+// src/domain/BemonyPaymentMethodInput.ts
+var BEMONY_PAYMENT_METHODS = [
+  "CREDIT_CARD",
+  "PIX",
+  "BOLETO",
+  "PAYPAL",
+  // 'GOOGLE_PAY',
+  // 'APPLE_PAY',
+  "OTHER"
+];
+function isValidBemonyPaymentMethod(input) {
+  if (!input) {
+    return false;
+  }
+  return BEMONY_PAYMENT_METHODS.includes(
+    input.paymentMethod
+  );
+}
+
+// src/domain/resolvePriceCode.ts
+function resolvePriceCode(input) {
+  if (!input) {
+    return { priceCode: null, conflict: false };
+  }
+  const fromCode = input.priceCode?.trim() || null;
+  const fromLegacy = input.priceId?.trim() || null;
+  if (fromCode && fromLegacy && fromCode !== fromLegacy) {
+    return { priceCode: fromCode, conflict: true };
+  }
+  return {
+    priceCode: fromCode ?? fromLegacy,
+    conflict: false
+  };
+}
+
+// src/navigation/extractPriceCodeFromUrl.ts
+function extractPriceCodeFromUrl(url) {
+  let pathname;
+  try {
+    pathname = typeof url === "string" ? new URL(url).pathname : url.pathname;
+  } catch {
+    return null;
+  }
+  const segments = pathname.split("/").filter((segment) => segment.length > 0);
+  for (let i = segments.length - 1; i >= 0; i -= 1) {
+    const segment = segments[i];
+    if (!segment) continue;
+    const bare = segment.replace(/\.[a-zA-Z0-9]+$/, "");
+    if (/^pri[_a-zA-Z0-9]*\d[_a-zA-Z0-9]*$/i.test(bare)) {
+      return bare;
+    }
+  }
+  return null;
+}
+
+// src/BemonyPixel.ts
+var SAFE_PUBLIC_ORDER_ID = /^[a-zA-Z0-9_.:-]+$/;
+var MAX_PUBLIC_ORDER_ID_LENGTH = 128;
+var BemonyLifecycleError = class extends Error {
+  constructor(options) {
+    super(options.message);
+    this.name = "BemonyLifecycleError";
+    this.code = options.code;
+    this.state = options.state;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+function requirePriceCode(input, method, state) {
+  const { priceCode, conflict } = resolvePriceCode(input);
+  if (!priceCode) {
+    throw new BemonyLifecycleError({
+      code: "INVALID_STATE",
+      message: `BemonyPixel.${method} requires priceCode.`,
+      state
+    });
+  }
+  if (conflict && typeof console !== "undefined" && console.debug) {
+    console.debug("[BemonyPixel] priceCode/priceId conflict; using priceCode", {
+      code: "BEMONY_PRICE_CODE_CONFLICT",
+      method
+    });
+  }
+  return priceCode;
+}
+function toViewContentData(input) {
+  const priceCode = resolvePriceCode(input).priceCode;
+  const contentType = input.productType === "downsell" ? "downsell" : input.productType === "upsell" ? "upsell" : "offer";
+  const observedValue = input.observedValue ?? input.price;
+  const observedCurrency = input.observedCurrency ?? input.currency;
+  return {
+    contentId: priceCode,
+    contentType,
+    productId: priceCode,
+    ...observedValue !== void 0 ? { value: observedValue } : {},
+    ...observedCurrency !== void 0 ? { currency: observedCurrency } : {}
+  };
+}
+function toAddToCartData(input) {
+  const priceCode = resolvePriceCode(input).priceCode;
+  const observedValue = input.observedValue ?? input.price;
+  const observedCurrency = input.observedCurrency ?? input.currency;
+  return {
+    productId: priceCode,
+    quantity: input.quantity ?? 1,
+    ...observedValue !== void 0 ? { price: observedValue } : {},
+    ...observedCurrency !== void 0 ? { currency: observedCurrency } : {}
+  };
+}
+function toLeadData(input) {
+  const fields = sanitizeLeadFields(input.fields);
+  return {
+    ...input.email !== void 0 ? { email: input.email.trim() } : {},
+    ...input.phone !== void 0 ? { phone: input.phone.trim() } : {},
+    ...input.name !== void 0 ? { name: input.name.trim() } : {},
+    ...fields !== void 0 ? { fields } : {}
+  };
+}
+function resolvePriceCodeFromAcceptElement(el) {
+  if (el instanceof HTMLAnchorElement && el.href) {
+    const fromHref = extractPriceCodeFromUrl(el.href);
+    if (fromHref) {
+      return fromHref;
+    }
+  }
+  const href = el.getAttribute("href");
+  if (!href) {
+    return null;
+  }
+  try {
+    const base = typeof window !== "undefined" && window.location?.href ? window.location.href : "https://localhost/";
+    return extractPriceCodeFromUrl(new URL(href, base));
+  } catch {
+    return null;
+  }
+}
+var BemonyPixel = class {
+  constructor(options) {
+    this.state = "created";
+    this.initPromise = null;
+    this.destroyPromise = null;
+    this.wrapperListeners = /* @__PURE__ */ new Set();
+    this.checkoutStarted = false;
+    this.lastLeadFingerprint = null;
+    this.selectedBumpIds = /* @__PURE__ */ new Set();
+    this.config = options.config;
+    this.scenario = options.scenario;
+    this.publicOrderId = options.publicOrderId?.trim() || void 0;
+    this.publicContext = options.publicContext ? { ...options.publicContext } : {};
+    this.autoInitiateCheckoutEnabled = options.autoInitiateCheckout !== false;
+    this.noThanksUrl = options.noThanksUrl?.trim() || void 0;
+    const createCore = options.createCorePixel ?? ((config) => new Pixel(config));
+    this.core = createCore(options.config);
+  }
+  getScenario() {
+    return this.scenario;
+  }
+  getConfig() {
+    return this.config;
+  }
+  getState() {
+    return this.state;
+  }
+  isInitialized() {
+    return this.state === "ready" && this.core.isInitialized();
+  }
+  getDebugSnapshot() {
+    return this.core.getDebugSnapshot();
+  }
+  /**
+   * `publicOrderId` do domínio do app (não mapeado para identity do Core).
+   * Fallback opcional: param `oid` da URL atual.
+   */
+  getPublicOrderId() {
+    if (this.publicOrderId) {
+      return this.publicOrderId;
+    }
+    if (typeof window === "undefined" || typeof window.location === "undefined") {
+      return null;
+    }
+    try {
+      return new URL(window.location.href).searchParams.get("oid");
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Define `publicOrderId` e propaga para managed param `oid` quando suportado.
+   */
+  setPublicOrderId(orderId) {
+    const trimmed = orderId.trim();
+    if (!trimmed || trimmed.length > MAX_PUBLIC_ORDER_ID_LENGTH) {
+      throw new BemonyLifecycleError({
+        code: "INVALID_STATE",
+        message: "setPublicOrderId requires a non-empty orderId within max length.",
+        state: this.state
+      });
+    }
+    if (!SAFE_PUBLIC_ORDER_ID.test(trimmed)) {
+      throw new BemonyLifecycleError({
+        code: "INVALID_STATE",
+        message: "setPublicOrderId orderId contains invalid characters.",
+        state: this.state
+      });
+    }
+    if (this.publicOrderId === trimmed) {
+      return;
+    }
+    this.publicOrderId = trimmed;
+    this.applyPublicOrderIdToManagedParam();
+  }
+  getPublicSessionId() {
+    if (typeof window === "undefined" || typeof window.location === "undefined") {
+      return null;
+    }
+    try {
+      return new URL(window.location.href).searchParams.get("sid");
+    } catch {
+      return null;
+    }
+  }
+  selectOffer(input) {
+    this.assertReady("selectOffer");
+    requirePriceCode(input, "selectOffer", this.state);
+    this.core.addToCart(toAddToCartData(input));
+  }
+  /**
+   * Inicia checkout → `Pixel.initiateCheckout()`.
+   * Idempotente: no máximo uma vez por lifecycle da instância.
+   */
+  startCheckout(input) {
+    this.assertReady("startCheckout");
+    if (this.checkoutStarted) {
+      return;
+    }
+    const data = input ? {
+      ...input.value !== void 0 ? { value: input.value } : {},
+      ...input.currency !== void 0 ? { currency: input.currency } : {}
+    } : void 0;
+    this.core.initiateCheckout(data);
+    this.checkoutStarted = true;
+  }
+  /**
+   * Captura lead → `Pixel.lead()`.
+   * Campos incompletos não disparam. Mesmo fingerprint não reenvia (debounce).
+   */
+  captureLead(input) {
+    this.assertReady("captureLead");
+    if (!isValidBemonyLead(input)) {
+      return false;
+    }
+    const fingerprint = leadFingerprint(input);
+    if (this.lastLeadFingerprint === fingerprint) {
+      return false;
+    }
+    this.core.lead(toLeadData(input));
+    this.lastLeadFingerprint = fingerprint;
+    return true;
+  }
+  selectOrderBump(input) {
+    this.assertReady("selectOrderBump");
+    const priceCode = requirePriceCode(input, "selectOrderBump", this.state);
+    this.core.addToCart(toAddToCartData(input));
+    this.selectedBumpIds.add(priceCode);
+  }
+  removeOrderBump(input) {
+    this.assertReady("removeOrderBump");
+    const priceCode = requirePriceCode(input, "removeOrderBump", this.state);
+    if (!this.selectedBumpIds.has(priceCode)) {
+      return;
+    }
+    this.core.removeFromCart({
+      // No adaptador Bemony, o campo genérico productId transporta o priceCode.
+      productId: priceCode,
+      ...input.quantity !== void 0 ? { quantity: input.quantity } : {}
+    });
+    this.selectedBumpIds.delete(priceCode);
+  }
+  trackPaymentMethod(input) {
+    this.assertReady("trackPaymentMethod");
+    if (!isValidBemonyPaymentMethod(input)) {
+      throw new BemonyLifecycleError({
+        code: "INVALID_STATE",
+        message: "trackPaymentMethod requires a valid paymentMethod enum.",
+        state: this.state
+      });
+    }
+    this.core.addPaymentInfo({ paymentMethod: input.paymentMethod });
+  }
+  viewUpsell(input) {
+    this.assertReady("viewUpsell");
+    requirePriceCode(input, "viewUpsell", this.state);
+    this.core.viewContent(toViewContentData(input));
+  }
+  acceptUpsell(input) {
+    this.assertReady("acceptUpsell");
+    requirePriceCode(input, "acceptUpsell", this.state);
+    this.core.addToCart(toAddToCartData(input));
+  }
+  /**
+   * Recusa de upsell/downsell — callback/navegação apenas.
+   * Destino: `navigateTo` explícito, senão `noThanksUrl` (data-no-thanks).
+   */
+  declineUpsell(options) {
+    this.assertReady("declineUpsell");
+    try {
+      options?.onDecline?.();
+    } finally {
+      const explicitTarget = options?.navigateTo?.trim() || this.noThanksUrl || void 0;
+      const target = explicitTarget ? this.decorateNavigateUrl(explicitTarget) : void 0;
+      if (target && typeof window !== "undefined" && typeof window.location?.assign === "function") {
+        window.location.assign(target);
+      }
+    }
+  }
+  /**
+   * Intenção de confirmação one-click → `Pixel.addToCart()`.
+   * Não processa pagamento e **não** emite PURCHASE.
+   */
+  trackOneClickConfirmation(input) {
+    this.assertReady("trackOneClickConfirmation");
+    this.assertOneClickReady("trackOneClickConfirmation");
+    requirePriceCode(input, "trackOneClickConfirmation", this.state);
+    this.core.addToCart(toAddToCartData(input));
+  }
+  init() {
+    if (this.state === "ready") {
+      return Promise.resolve();
+    }
+    if (this.state === "initializing" && this.initPromise) {
+      return this.initPromise;
+    }
+    if (this.state === "destroying" && this.destroyPromise) {
+      this.initPromise = this.destroyPromise.catch(() => void 0).then(() => this.startInit());
+      return this.initPromise;
+    }
+    this.initPromise = this.startInit();
+    return this.initPromise;
+  }
+  destroy() {
+    if (this.state === "destroyed") {
+      return Promise.resolve();
+    }
+    if (this.state === "destroying" && this.destroyPromise) {
+      return this.destroyPromise;
+    }
+    if (this.state === "initializing" && this.initPromise) {
+      this.destroyPromise = this.initPromise.catch(() => void 0).then(() => this.startDestroy());
+      return this.destroyPromise;
+    }
+    this.destroyPromise = this.startDestroy();
+    return this.destroyPromise;
+  }
+  addWrapperListener(cleanup) {
+    this.wrapperListeners.add(cleanup);
+    return () => {
+      this.wrapperListeners.delete(cleanup);
+    };
+  }
+  assertReady(method) {
+    if (this.state !== "ready") {
+      throw new BemonyLifecycleError({
+        code: "INVALID_STATE",
+        message: `BemonyPixel.${method} requires state "ready" (current: "${this.state}").`,
+        state: this.state
+      });
+    }
+  }
+  assertOneClickReady(method) {
+    if (!this.getPublicOrderId()) {
+      throw new BemonyLifecycleError({
+        code: "INVALID_STATE",
+        message: `BemonyPixel.${method} requires publicOrderId.`,
+        state: this.state
+      });
+    }
+  }
+  applyPublicOrderIdToManagedParam() {
+    if (!this.publicOrderId || !this.core.setManagedUrlParam) {
+      return;
+    }
+    this.core.setManagedUrlParam("oid", this.publicOrderId);
+  }
+  decorateNavigateUrl(rawUrl) {
+    try {
+      const base = typeof window !== "undefined" && window.location?.href ? window.location.href : "https://localhost/";
+      const url = new URL(rawUrl, base);
+      const sid = this.getPublicSessionId();
+      const oid = this.getPublicOrderId();
+      const fid = this.publicContext.funnelId;
+      const fsid = this.publicContext.funnelStepId;
+      const afid = this.publicContext.affiliateId;
+      if (sid && !url.searchParams.has("sid")) {
+        url.searchParams.set("sid", sid);
+      }
+      if (oid && !url.searchParams.has("oid")) {
+        url.searchParams.set("oid", oid);
+      }
+      if (fid && !url.searchParams.has("fid")) {
+        url.searchParams.set("fid", fid);
+      }
+      if (fsid && !url.searchParams.has("fsid")) {
+        url.searchParams.set("fsid", fsid);
+      }
+      if (afid && !url.searchParams.has("afid")) {
+        url.searchParams.set("afid", afid);
+      }
+      return url.toString();
+    } catch {
+      return rawUrl;
+    }
+  }
+  maybeAutoInitiateCheckout() {
+    if (this.scenario !== "checkout" && this.scenario !== "one-click-checkout") {
+      return;
+    }
+    if (!this.autoInitiateCheckoutEnabled || this.checkoutStarted) {
+      return;
+    }
+    this.core.initiateCheckout();
+    this.checkoutStarted = true;
+  }
+  resetDomainState() {
+    this.checkoutStarted = false;
+    this.lastLeadFingerprint = null;
+    this.selectedBumpIds.clear();
+    this.publicOrderId = void 0;
+  }
+  startInit() {
+    this.state = "initializing";
+    return this.core.init().then(() => {
+      if (this.publicOrderId) {
+        this.applyPublicOrderIdToManagedParam();
+      }
+    }).then(() => {
+      this.state = "ready";
+      this.maybeAutoInitiateCheckout();
+    }).catch((error) => {
+      this.state = "failed";
+      return this.safeCoreDestroy().then(() => {
+        throw new BemonyLifecycleError({
+          code: "INIT_FAILED",
+          message: "BemonyPixel init failed.",
+          state: this.state,
+          cause: error
+        });
+      });
+    }).finally(() => {
+      this.initPromise = null;
+    });
+  }
+  startDestroy() {
+    this.state = "destroying";
+    return this.safeCoreDestroy().then(() => {
+      this.clearWrapperListeners();
+      this.resetDomainState();
+      this.state = "destroyed";
+    }).catch((error) => {
+      this.clearWrapperListeners();
+      this.resetDomainState();
+      this.state = "destroyed";
+      throw new BemonyLifecycleError({
+        code: "DESTROY_FAILED",
+        message: "BemonyPixel destroy failed.",
+        state: this.state,
+        cause: error
+      });
+    }).finally(() => {
+      this.destroyPromise = null;
+    });
+  }
+  async safeCoreDestroy() {
+    await this.core.destroy();
+  }
+  clearWrapperListeners() {
+    for (const cleanup of this.wrapperListeners) {
+      try {
+        cleanup();
+      } catch {
+      }
+    }
+    this.wrapperListeners.clear();
+  }
+};
+
+// src/createBemonyPixel.ts
+function createJourneyStorage() {
+  return new StorageServiceImpl(
+    createStorageAdapter("localStorage"),
+    "bemony",
+    "urlctx"
+  );
+}
+function seedJourneyManagedParams(journey, publicContext) {
+  if (publicContext.funnelId) {
+    journey.setManagedParam("fid", publicContext.funnelId);
+  }
+  if (publicContext.funnelStepId) {
+    journey.setManagedParam("fsid", publicContext.funnelStepId);
+  }
+  if (publicContext.publicOrderId) {
+    journey.setManagedParam("oid", publicContext.publicOrderId);
+  }
+  if (publicContext.affiliateId) {
+    journey.setManagedParam("afid", publicContext.affiliateId);
+  }
+}
+async function createBemonyPixel(options) {
+  const pageInput = normalizeBemonyPageContextInput(options.page);
+  const publicContext = validateBemonyPageContext({
+    scenario: options.scenario,
+    publicContext: resolveBemonyPageContext({
+      input: pageInput.public,
+      urlParams: options.urlParams,
+      pageMetadata: options.pageMetadata,
+      scenarioDefaults: options.scenarioDefaults
+    })
+  });
+  const allowedDomains = options.overrides?.allowedDomains ?? options.platform.allowedDomains;
+  const journeyUrlConfig = configureBemonyLinks({
+    allowedDomains: allowedDomains ? [...allowedDomains] : []
+  });
+  const journeyStorage = createJourneyStorage();
+  const journey = prepareJourneyUrlContext(journeyUrlConfig, journeyStorage);
+  seedJourneyManagedParams(journey, publicContext);
+  const config = createBemonyPixelConfig({
+    ...options,
+    page: { public: publicContext }
+  });
+  const construct = {
+    config,
+    scenario: options.scenario,
+    publicOrderId: publicContext.publicOrderId,
+    publicContext,
+    autoInitiateCheckout: options.autoInitiateCheckout,
+    ...options.noThanksUrl ? { noThanksUrl: options.noThanksUrl } : {},
+    ...options.createCorePixel ? { createCorePixel: options.createCorePixel } : {}
+  };
+  try {
+    const instance = new BemonyPixel(construct);
+    await instance.init();
+    return instance;
+  } finally {
+    journey.destroy();
+  }
+}
+
+// src/scenarios/types.ts
+var BEMONY_SCENARIOS = [
+  "offer-page",
+  "checkout",
+  "upsell-offer",
+  "one-click-checkout",
+  "thank-you"
+];
+
+// src/contracts/validateBackendPurchase.ts
+var BLOCKED_REDIRECT_KEYS = /^(token|one_click_token|oneClickToken|access_token|password|card|cvv|pan)$/i;
+function validateBemonyServerPurchasePlaceholder(payload) {
+  if (!payload || typeof payload !== "object") {
+    throw new BemonyValidationError({
+      code: "INVALID_FIELD",
+      field: "payload",
+      message: "Server purchase payload must be an object (placeholder contract)."
+    });
+  }
+  const value = payload;
+  if (value.type !== "PURCHASE") {
+    throw new BemonyValidationError({
+      code: "INVALID_FIELD",
+      field: "type",
+      message: 'Placeholder purchase payload requires type "PURCHASE".'
+    });
+  }
+  if (typeof value.event_id !== "string" || !value.event_id.trim()) {
+    throw new BemonyValidationError({
+      code: "MISSING_REQUIRED_FIELD",
+      field: "event_id",
+      message: "Placeholder purchase payload requires event_id."
+    });
+  }
+  if (typeof value.occurred_at !== "string" || !value.occurred_at.trim()) {
+    throw new BemonyValidationError({
+      code: "MISSING_REQUIRED_FIELD",
+      field: "occurred_at",
+      message: "Placeholder purchase payload requires occurred_at."
+    });
+  }
+  return payload;
+}
+function assertSafePublicRedirectParams(params) {
+  const attribution = params.attribution ? { ...params.attribution } : void 0;
+  if (attribution) {
+    for (const key of Object.keys(attribution)) {
+      if (BLOCKED_REDIRECT_KEYS.test(key)) {
+        throw new BemonyValidationError({
+          code: "INVALID_FIELD",
+          field: key,
+          message: "Redirect params must not include secrets (token/card/etc.)."
+        });
+      }
+    }
+  }
+  return {
+    ...params.sid !== void 0 ? { sid: params.sid } : {},
+    ...params.public_order_id !== void 0 ? { public_order_id: params.public_order_id } : {},
+    ...params.funnel_id !== void 0 ? { funnel_id: params.funnel_id } : {},
+    ...params.offer_id !== void 0 ? { offer_id: params.offer_id } : {},
+    ...attribution !== void 0 ? { attribution } : {}
+  };
+}
+function buildPublicRedirectQuery(params) {
+  const safe = assertSafePublicRedirectParams(params);
+  const search = new URLSearchParams();
+  if (safe.sid) search.set("sid", safe.sid);
+  if (safe.public_order_id) search.set("public_order_id", safe.public_order_id);
+  if (safe.funnel_id) search.set("funnel_id", safe.funnel_id);
+  if (safe.offer_id) search.set("offer_id", safe.offer_id);
+  if (safe.attribution) {
+    for (const [key, value] of Object.entries(safe.attribution)) {
+      search.set(key, value);
+    }
+  }
+  const query = search.toString();
+  return query ? `?${query}` : "";
+}
+
+// src/domain/BemonyOfferInput.ts
+function isCompleteBemonyOffer(input) {
+  return resolvePriceCode(input).priceCode !== null;
+}
+export {
+  BEMONY_AFID_MANAGED_PARAM,
+  BEMONY_BROWSER_AUTO_INIT_DEFAULTS,
+  BEMONY_DEFAULT_ALLOWED_DOMAINS,
+  BEMONY_DEFAULT_API_ENDPOINT,
+  BEMONY_DEFAULT_BROWSER_ENVIRONMENT,
+  BEMONY_DEFAULT_BROWSER_SCENARIO,
+  BEMONY_DEFAULT_NAMESPACE,
+  BEMONY_DEFAULT_PIXEL_ID,
+  BEMONY_ENVIRONMENTS,
+  BEMONY_FORWARD_DENYLIST,
+  BEMONY_PAYMENT_METHODS,
+  BEMONY_PLATFORM_DEFAULTS,
+  BEMONY_SCENARIOS,
+  BEMONY_SID_MANAGED_PARAM,
+  BEMONY_STORAGE_PREFIX,
+  BEMONY_UPSELL_BUY_LINK_SELECTOR,
+  BEMONY_UPSELL_LINK_SELECTOR,
+  BemonyLifecycleError,
+  BemonyPixel,
+  BemonyValidationError,
+  DEFAULT_BEMONY_LINK_SELECTOR,
+  REQUIRED_PUBLIC_FIELDS,
+  applyCheckoutScenario,
+  applyOfferPageScenario,
+  applyOneClickCheckoutScenario,
+  applyThankYouScenario,
+  applyUpsellOfferScenario,
+  assertSafePublicRedirectParams,
+  buildPublicRedirectQuery,
+  buildUpsellLinkSelector,
+  configureBemonyLinks,
+  createBemonyLinkPolicy,
+  createBemonyOfferLinkSource,
+  createBemonyPixel,
+  createBemonyPixelConfig,
+  extractPriceCodeFromUrl,
+  hrefMatchesNoThanksUrl,
+  isBemonyPageContextInput,
+  isCompleteBemonyOffer,
+  isValidBemonyLead,
+  isValidBemonyPaymentMethod,
+  leadFingerprint,
+  normalizeAllowedDomain,
+  normalizeAllowedDomains,
+  normalizeBemonyPageContextInput,
+  resolveBemonyEnvironment,
+  resolveBemonyPageContext,
+  resolvePriceCode,
+  resolvePriceCodeFromAcceptElement,
+  sanitizeLeadFields,
+  validateBemonyPageContext,
+  validateBemonyServerPurchasePlaceholder
+};
+//# sourceMappingURL=index.esm.js.map