@beworke/pixel-bemony 0.1.0-rc.1

package/dist/browser/index.esm.js

@@ -0,0 +1,2557 @@
+// 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/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 } : {}
+  };
+}
+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/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
+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]';
+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 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
+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/browser/errors.ts
+var BemonyBootstrapError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.name = "BemonyBootstrapError";
+    this.code = code;
+    if (cause !== void 0) {
+      this.cause = cause;
+    }
+  }
+};
+
+// src/browser/events.ts
+var BEMONY_PIXEL_READY_EVENT = "bemony:pixel:ready";
+var BEMONY_PIXEL_ERROR_EVENT = "bemony:pixel:error";
+var BEMONY_PIXEL_INITIALIZING_EVENT = "bemony:pixel:initializing";
+var BEMONY_PIXEL_DESTROYED_EVENT = "bemony:pixel:destroyed";
+function safeDispatch(type, detail) {
+  if (typeof window === "undefined" || typeof CustomEvent === "undefined") {
+    return;
+  }
+  try {
+    window.dispatchEvent(new CustomEvent(type, { detail }));
+  } catch {
+  }
+}
+function emitBemonyPixelReady(pixel) {
+  safeDispatch(BEMONY_PIXEL_READY_EVENT, {
+    pixel
+  });
+}
+function emitBemonyPixelError(code, message) {
+  safeDispatch(BEMONY_PIXEL_ERROR_EVENT, {
+    code,
+    message
+  });
+}
+function emitBemonyPixelInitializing() {
+  safeDispatch(BEMONY_PIXEL_INITIALIZING_EVENT, {});
+}
+function emitBemonyPixelDestroyed() {
+  safeDispatch(BEMONY_PIXEL_DESTROYED_EVENT, {});
+}
+
+// src/browser/bootstrap.ts
+var WINDOW_STORE_KEY = "__bemony_pixel_bootstrap__";
+function assertBrowser() {
+  if (typeof window === "undefined") {
+    throw new BemonyBootstrapError(
+      "bootstrapBemonyPixel s\xF3 pode ser usado no browser (window ausente).",
+      "NOT_BROWSER"
+    );
+  }
+}
+function getStore() {
+  assertBrowser();
+  const win = window;
+  if (!win[WINDOW_STORE_KEY]) {
+    win[WINDOW_STORE_KEY] = {
+      instance: null,
+      pending: null,
+      readyEmittedFor: null
+    };
+  }
+  return win[WINDOW_STORE_KEY];
+}
+function isReusableInstance(instance) {
+  const state = instance.getState();
+  return state === "ready" || state === "initializing";
+}
+async function bootstrapBemonyPixel(options) {
+  assertBrowser();
+  const store = getStore();
+  const { force = false, waitForConsent, ...pixelOptions } = options;
+  if (!force) {
+    if (store.pending) {
+      return store.pending;
+    }
+    if (store.instance && isReusableInstance(store.instance)) {
+      return store.instance;
+    }
+  }
+  if (force) {
+    if (store.pending) {
+      try {
+        await store.pending;
+      } catch {
+      }
+      store.pending = null;
+    }
+    if (store.instance) {
+      try {
+        await store.instance.destroy();
+      } catch {
+      }
+      store.instance = null;
+      store.readyEmittedFor = null;
+    }
+  }
+  if (waitForConsent) {
+    const allowed = await waitForConsent();
+    if (!allowed) {
+      const error = new BemonyBootstrapError(
+        "Consentimento negado \u2014 bootstrap abortado.",
+        "CONSENT_DENIED"
+      );
+      emitBemonyPixelError(error.code, error.message);
+      throw error;
+    }
+  }
+  emitBemonyPixelInitializing();
+  const pending = createBemonyPixel(pixelOptions).then((instance) => {
+    store.instance = instance;
+    if (store.pending === pending) {
+      store.pending = null;
+    }
+    if (store.readyEmittedFor !== instance) {
+      emitBemonyPixelReady(instance);
+      store.readyEmittedFor = instance;
+    }
+    return instance;
+  }).catch((error) => {
+    if (store.pending === pending) {
+      store.pending = null;
+    }
+    const code = error instanceof BemonyBootstrapError ? error.code : "AUTO_INIT_FAILED";
+    const message = error instanceof Error ? error.message : "Bootstrap falhou";
+    emitBemonyPixelError(code, message);
+    throw error;
+  });
+  store.pending = pending;
+  return pending;
+}
+function getBootstrappedBemonyPixel() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const store = window[WINDOW_STORE_KEY];
+  return store?.instance ?? null;
+}
+function getBootstrappedBemonyPixelPending() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const store = window[WINDOW_STORE_KEY];
+  return store?.pending ?? null;
+}
+async function destroyBootstrappedBemonyPixel() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  const store = getStore();
+  if (store.pending) {
+    try {
+      await store.pending;
+    } catch {
+    }
+    store.pending = null;
+  }
+  if (store.instance) {
+    await store.instance.destroy();
+    store.instance = null;
+    store.readyEmittedFor = null;
+    emitBemonyPixelDestroyed();
+  }
+}
+
+// src/scenarios/types.ts
+var BEMONY_SCENARIOS = [
+  "offer-page",
+  "checkout",
+  "upsell-offer",
+  "one-click-checkout",
+  "thank-you"
+];
+
+// src/browser/resolveExecutingScript.ts
+var BEMONY_GLOBAL_BUNDLE_FILENAME = "pixel-bemony.global.js";
+var LEGACY_SCRIPT_SELECTOR = "script[data-bemony-pixel]";
+function isHtmlScript(el) {
+  return !!el && typeof HTMLScriptElement !== "undefined" && el instanceof HTMLScriptElement;
+}
+function isBemonyGlobalBundleSrc(src) {
+  if (!src || !src.trim()) {
+    return false;
+  }
+  try {
+    const base = typeof location !== "undefined" && location.href ? location.href : "https://example.invalid/";
+    const url = new URL(src.trim(), base);
+    const path = url.pathname.toLowerCase();
+    return path === `/${BEMONY_GLOBAL_BUNDLE_FILENAME}` || path.endsWith(`/${BEMONY_GLOBAL_BUNDLE_FILENAME}`);
+  } catch {
+    const normalized = src.trim().toLowerCase().split(/[?#]/)[0] ?? "";
+    return normalized === BEMONY_GLOBAL_BUNDLE_FILENAME || normalized.endsWith(`/${BEMONY_GLOBAL_BUNDLE_FILENAME}`);
+  }
+}
+function resolveBemonyExecutingScript(input = {}) {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  const current = input.currentScript !== void 0 ? input.currentScript : typeof document.currentScript !== "undefined" ? document.currentScript : null;
+  if (isHtmlScript(current)) {
+    return current;
+  }
+  const root = input.root ?? document;
+  const allScripts = Array.from(root.querySelectorAll("script"));
+  const bySrc = allScripts.filter(
+    (el) => isHtmlScript(el) && isBemonyGlobalBundleSrc(el.getAttribute("src"))
+  );
+  if (bySrc.length === 1) {
+    return bySrc[0];
+  }
+  if (bySrc.length > 1) {
+    throw new BemonyBootstrapError(
+      `Encontrados ${bySrc.length} scripts com src de ${BEMONY_GLOBAL_BUNDLE_FILENAME}; n\xE3o \xE9 poss\xEDvel determinar qual est\xE1 em execu\xE7\xE3o.`,
+      "AMBIGUOUS_SCRIPT"
+    );
+  }
+  const legacy = Array.from(
+    root.querySelectorAll(LEGACY_SCRIPT_SELECTOR)
+  ).filter(isHtmlScript);
+  if (legacy.length === 1) {
+    return legacy[0];
+  }
+  return null;
+}
+
+// src/browser/resolveAutoInitConfig.ts
+var BEMONY_FORBIDDEN_DATA_ATTRIBUTES = [
+  "data-token",
+  "data-one-click-token",
+  "data-oneclick-token",
+  "data-ephemeral-token",
+  "data-payment-token",
+  "data-oc-token",
+  "data-secret",
+  "data-auth-token"
+];
+var SCRIPT_SELECTOR = "script[data-bemony-pixel]";
+function isEnvironment(value) {
+  return BEMONY_ENVIRONMENTS.includes(value);
+}
+function isScenario(value) {
+  return BEMONY_SCENARIOS.includes(value);
+}
+function parseBooleanAttr(value) {
+  if (value === null) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "1" || normalized === "") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0") {
+    return false;
+  }
+  return void 0;
+}
+function isAutoInitEnabledFromAttr(value) {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  const parsed = parseBooleanAttr(value);
+  if (parsed === void 0) {
+    throw new BemonyBootstrapError(
+      `data-auto-init inv\xE1lido (recebido: ${value}). Use true/false/1/0.`,
+      "INVALID_ATTRIBUTES"
+    );
+  }
+  return parsed;
+}
+function assertNoForbiddenAttributes(el) {
+  for (const name of BEMONY_FORBIDDEN_DATA_ATTRIBUTES) {
+    if (el.hasAttribute(name)) {
+      throw new BemonyBootstrapError(
+        `Atributo proibido em script tag: ${name}. Token one-click n\xE3o pode ir em data-*.`,
+        "FORBIDDEN_ATTRIBUTE"
+      );
+    }
+  }
+  for (const attr of Array.from(el.attributes)) {
+    if (attr.name.startsWith("data-") && attr.name.includes("token")) {
+      throw new BemonyBootstrapError(
+        `Atributo proibido em script tag: ${attr.name}. Token n\xE3o permitido em data-*.`,
+        "FORBIDDEN_ATTRIBUTE"
+      );
+    }
+  }
+}
+function nonEmpty(value) {
+  if (value === null || value === void 0) return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function readPublicPageFromDataset(el) {
+  const pageId = nonEmpty(el.getAttribute("data-page-id"));
+  const funnelId = nonEmpty(el.getAttribute("data-funnel-id"));
+  const funnelStepId = nonEmpty(el.getAttribute("data-funnel-step-id"));
+  const offerId = nonEmpty(el.getAttribute("data-offer-id"));
+  const productId = nonEmpty(el.getAttribute("data-product-id"));
+  const priceCode = nonEmpty(el.getAttribute("data-price-code"));
+  const checkoutId = nonEmpty(el.getAttribute("data-checkout-id"));
+  const publicOrderId = nonEmpty(el.getAttribute("data-public-order-id"));
+  if (!pageId && !funnelId && !funnelStepId && !offerId && !productId && !priceCode && !checkoutId && !publicOrderId) {
+    return void 0;
+  }
+  return {
+    ...pageId ? { pageId } : {},
+    ...funnelId ? { funnelId } : {},
+    ...funnelStepId ? { funnelStepId } : {},
+    ...offerId ? { offerId } : {},
+    ...productId ? { productId } : {},
+    ...priceCode ? { priceCode } : {},
+    ...checkoutId ? { checkoutId } : {},
+    ...publicOrderId ? { publicOrderId } : {}
+  };
+}
+function cloneDefaults() {
+  return {
+    environment: BEMONY_BROWSER_AUTO_INIT_DEFAULTS.environment,
+    scenario: BEMONY_BROWSER_AUTO_INIT_DEFAULTS.scenario,
+    platform: {
+      pixelId: BEMONY_BROWSER_AUTO_INIT_DEFAULTS.platform.pixelId,
+      apiEndpoint: BEMONY_BROWSER_AUTO_INIT_DEFAULTS.platform.apiEndpoint,
+      namespace: BEMONY_BROWSER_AUTO_INIT_DEFAULTS.platform.namespace,
+      allowedDomains: [
+        ...BEMONY_BROWSER_AUTO_INIT_DEFAULTS.platform.allowedDomains
+      ]
+    }
+  };
+}
+function mergePlatform(base, overlay) {
+  if (!overlay) return { ...base };
+  const pixelId = overlay.pixelId !== void 0 && overlay.pixelId.trim() !== "" ? overlay.pixelId.trim() : base.pixelId;
+  const apiEndpoint = overlay.apiEndpoint !== void 0 ? overlay.apiEndpoint.trim() || base.apiEndpoint : base.apiEndpoint;
+  const namespace = overlay.namespace !== void 0 ? overlay.namespace.trim() || base.namespace : base.namespace;
+  return {
+    ...base,
+    pixelId,
+    ...apiEndpoint !== void 0 ? { apiEndpoint } : {},
+    ...namespace !== void 0 ? { namespace } : {},
+    ...overlay.debug !== void 0 ? { debug: overlay.debug } : {},
+    allowedDomains: overlay.allowedDomains !== void 0 ? (() => {
+      const cleaned = overlay.allowedDomains.filter(
+        (d) => d.trim().length > 0
+      );
+      return cleaned.length > 0 ? cleaned : base.allowedDomains;
+    })() : base.allowedDomains
+  };
+}
+function mergePage(base, overlay) {
+  if (!overlay && !base) return void 0;
+  if (!overlay) return base;
+  if (!base) return overlay;
+  const baseNorm = base && "public" in base ? base : { public: base };
+  const overlayNorm = overlay && "public" in overlay ? overlay : { public: overlay };
+  const basePublic = baseNorm && "public" in baseNorm ? baseNorm.public ?? {} : {};
+  const overlayPublic = overlayNorm && "public" in overlayNorm ? overlayNorm.public ?? {} : {};
+  return {
+    ...baseNorm,
+    ...overlayNorm,
+    public: {
+      ...basePublic,
+      ...overlayPublic
+    }
+  };
+}
+function mergeOverrides(base, overlay) {
+  if (!overlay && !base) return void 0;
+  if (!overlay) return base ? { ...base } : void 0;
+  if (!base) return { ...overlay };
+  const apiEndpoint = overlay.apiEndpoint !== void 0 ? overlay.apiEndpoint.trim() || base.apiEndpoint : base.apiEndpoint;
+  return {
+    ...base,
+    ...overlay,
+    ...apiEndpoint !== void 0 ? { apiEndpoint } : {},
+    allowedDomains: overlay.allowedDomains !== void 0 ? overlay.allowedDomains.filter((d) => d.trim().length > 0) : base.allowedDomains
+  };
+}
+function mergeBemonyPixelOptions(base, overlay) {
+  const environment = overlay.environment && isEnvironment(overlay.environment) ? overlay.environment : base.environment;
+  const scenario = overlay.scenario && isScenario(overlay.scenario) ? overlay.scenario : base.scenario;
+  const merged = {
+    environment,
+    scenario,
+    platform: mergePlatform(base.platform, overlay.platform)
+  };
+  const page = mergePage(base.page, overlay.page);
+  if (page !== void 0) merged.page = page;
+  const commerce = overlay.commerce ?? base.commerce;
+  if (commerce !== void 0) merged.commerce = commerce;
+  const overrides = mergeOverrides(base.overrides, overlay.overrides);
+  if (overrides !== void 0) merged.overrides = overrides;
+  const autoInitiateCheckout = overlay.autoInitiateCheckout ?? base.autoInitiateCheckout;
+  if (autoInitiateCheckout !== void 0) {
+    merged.autoInitiateCheckout = autoInitiateCheckout;
+  }
+  const noThanksUrl = overlay.noThanksUrl ?? base.noThanksUrl;
+  if (noThanksUrl !== void 0 && noThanksUrl.trim() !== "") {
+    merged.noThanksUrl = noThanksUrl.trim();
+  }
+  if ("createCorePixel" in overlay && overlay.createCorePixel) {
+    merged.createCorePixel = overlay.createCorePixel;
+  } else if (base.createCorePixel) {
+    merged.createCorePixel = base.createCorePixel;
+  }
+  return merged;
+}
+function parseBemonyScriptAttributes(el) {
+  assertNoForbiddenAttributes(el);
+  const htmlEl = el;
+  const environmentRaw = nonEmpty(htmlEl.getAttribute("data-environment"));
+  const scenarioRaw = nonEmpty(htmlEl.getAttribute("data-scenario"));
+  if (environmentRaw !== void 0 && !isEnvironment(environmentRaw)) {
+    throw new BemonyBootstrapError(
+      `data-environment inv\xE1lido (recebido: ${environmentRaw}).`,
+      "INVALID_ATTRIBUTES"
+    );
+  }
+  if (scenarioRaw !== void 0 && !isScenario(scenarioRaw)) {
+    throw new BemonyBootstrapError(
+      `data-scenario inv\xE1lido (recebido: ${scenarioRaw}).`,
+      "INVALID_ATTRIBUTES"
+    );
+  }
+  const pixelId = nonEmpty(htmlEl.getAttribute("data-pixel-id")) ?? nonEmpty(htmlEl.getAttribute("data-funnel-id"));
+  const namespace = nonEmpty(htmlEl.getAttribute("data-namespace"));
+  const apiEndpoint = nonEmpty(htmlEl.getAttribute("data-api-endpoint"));
+  const debug = parseBooleanAttr(htmlEl.getAttribute("data-debug"));
+  const allowedDomainsRaw = nonEmpty(
+    htmlEl.getAttribute("data-allowed-domains")
+  );
+  const allowedDomains = allowedDomainsRaw ? allowedDomainsRaw.split(",").map((d) => d.trim()).filter(Boolean) : void 0;
+  const pagePublic = readPublicPageFromDataset(htmlEl);
+  const partial = {};
+  if (environmentRaw) partial.environment = environmentRaw;
+  if (scenarioRaw) partial.scenario = scenarioRaw;
+  if (pixelId || namespace || apiEndpoint || allowedDomains || debug !== void 0) {
+    partial.platform = {
+      pixelId: pixelId ?? BEMONY_DEFAULT_PIXEL_ID,
+      ...namespace ? { namespace } : {},
+      ...apiEndpoint ? { apiEndpoint } : {},
+      ...allowedDomains ? { allowedDomains } : {},
+      ...debug !== void 0 ? { debug } : {}
+    };
+  }
+  if (pagePublic) {
+    partial.page = { public: pagePublic };
+  }
+  if (apiEndpoint || debug !== void 0) {
+    partial.overrides = {
+      ...apiEndpoint ? { apiEndpoint } : {},
+      ...debug !== void 0 ? { debug } : {}
+    };
+  }
+  const autoInitiateCheckout = parseBooleanAttr(
+    htmlEl.getAttribute("data-auto-initiate-checkout")
+  );
+  if (autoInitiateCheckout !== void 0) {
+    partial.autoInitiateCheckout = autoInitiateCheckout;
+  }
+  const noThanksUrl = nonEmpty(htmlEl.getAttribute("data-no-thanks"));
+  if (noThanksUrl) {
+    partial.noThanksUrl = noThanksUrl;
+  }
+  return partial;
+}
+function readWindowConfig() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  const config = window.BemonyPixelConfig;
+  return config && typeof config === "object" ? config : null;
+}
+function assertValidWindowConfigPartial(config) {
+  if (config.environment !== void 0 && !isEnvironment(config.environment)) {
+    throw new BemonyBootstrapError(
+      "window.BemonyPixelConfig.environment inv\xE1lido.",
+      "INVALID_CONFIG"
+    );
+  }
+  if (config.scenario !== void 0 && !isScenario(config.scenario)) {
+    throw new BemonyBootstrapError(
+      "window.BemonyPixelConfig.scenario inv\xE1lido.",
+      "INVALID_CONFIG"
+    );
+  }
+  if (config.platform?.pixelId !== void 0 && config.platform.pixelId.trim() === "") {
+    throw new BemonyBootstrapError(
+      "window.BemonyPixelConfig.platform.pixelId n\xE3o pode ser vazio.",
+      "INVALID_CONFIG"
+    );
+  }
+}
+function resolveAutoInitConfig(input = {}) {
+  const applyDefaults = input.applyDefaults !== false;
+  if (typeof document === "undefined" && typeof window === "undefined") {
+    if (input.config && applyDefaults) {
+      return {
+        options: mergeBemonyPixelOptions(cloneDefaults(), input.config),
+        source: "explicit",
+        sources: ["default", "explicit"],
+        script: null
+      };
+    }
+    if (input.config) {
+      return {
+        options: input.config,
+        source: "explicit",
+        sources: ["explicit"],
+        script: null
+      };
+    }
+    return null;
+  }
+  const sources = [];
+  let options = applyDefaults ? cloneDefaults() : null;
+  if (applyDefaults) {
+    sources.push("default");
+  }
+  const windowConfig = readWindowConfig();
+  if (windowConfig) {
+    assertValidWindowConfigPartial(windowConfig);
+    if (!options) {
+      options = cloneDefaults();
+      if (!sources.includes("default")) sources.push("default");
+    }
+    options = mergeBemonyPixelOptions(options, windowConfig);
+    sources.push("window-config");
+  }
+  let script = input.script ?? null;
+  if (script === null && input.script === void 0) {
+    const root = input.root ?? (typeof document !== "undefined" ? document : void 0);
+    try {
+      script = resolveBemonyExecutingScript({
+        ...root ? { root } : {}
+      });
+    } catch (error) {
+      if (error instanceof BemonyBootstrapError && error.code === "AMBIGUOUS_SCRIPT") {
+        throw error;
+      }
+      script = null;
+    }
+    if (!script && root) {
+      const legacyAuto = Array.from(
+        root.querySelectorAll(`${SCRIPT_SELECTOR}[data-auto-init]`)
+      );
+      if (legacyAuto.length > 1) {
+        throw new BemonyBootstrapError(
+          `Encontrados ${legacyAuto.length} scripts com data-bemony-pixel + data-auto-init; use apenas um.`,
+          "MULTIPLE_SCRIPTS"
+        );
+      }
+      if (legacyAuto.length === 1) {
+        script = legacyAuto[0];
+      }
+    }
+  }
+  if (script) {
+    const fromAttrs = parseBemonyScriptAttributes(script);
+    if (!options) {
+      options = cloneDefaults();
+      if (!sources.includes("default")) sources.push("default");
+    }
+    options = mergeBemonyPixelOptions(options, fromAttrs);
+    sources.push("data-attributes");
+  }
+  if (input.config) {
+    if (!options) {
+      options = { ...input.config };
+      sources.push("explicit");
+    } else {
+      options = mergeBemonyPixelOptions(options, input.config);
+      sources.push("explicit");
+    }
+  }
+  if (!options) {
+    return null;
+  }
+  if (!options.platform.pixelId?.trim()) {
+    options = mergeBemonyPixelOptions(options, {
+      platform: {
+        pixelId: BEMONY_DEFAULT_PIXEL_ID,
+        namespace: BEMONY_DEFAULT_NAMESPACE,
+        apiEndpoint: BEMONY_DEFAULT_API_ENDPOINT
+      }
+    });
+  }
+  if ((options.environment === "staging" || options.environment === "production") && !options.platform.apiEndpoint?.trim() && !options.overrides?.apiEndpoint?.trim()) {
+    options = mergeBemonyPixelOptions(options, {
+      platform: {
+        pixelId: options.platform.pixelId,
+        apiEndpoint: BEMONY_DEFAULT_API_ENDPOINT
+      }
+    });
+  }
+  const highest = sources[sources.length - 1] ?? "default";
+  const source = sources.length > 1 ? "merged" : highest;
+  return {
+    options,
+    source: sources.length === 1 ? highest : source,
+    sources,
+    script
+  };
+}
+
+// src/browser/autoInit.ts
+async function installBemonyPixelAutoInit(options = {}) {
+  if (typeof window === "undefined") {
+    throw new BemonyBootstrapError(
+      "installBemonyPixelAutoInit s\xF3 pode ser usado no browser.",
+      "NOT_BROWSER"
+    );
+  }
+  const script = options.script !== void 0 ? options.script : resolveBemonyExecutingScript({
+    ...options.root ? { root: options.root } : {}
+  });
+  if (script) {
+    const autoInitAttr = script.getAttribute("data-auto-init");
+    if (!options.config && autoInitAttr !== null && !isAutoInitEnabledFromAttr(autoInitAttr)) {
+      return null;
+    }
+  }
+  const resolved = resolveAutoInitConfig({
+    config: options.config,
+    root: options.root,
+    script,
+    applyDefaults: options.applyDefaults
+  });
+  if (!resolved) {
+    return null;
+  }
+  if (options.requireDataAutoInit && !options.config && !resolved.sources.includes("data-attributes")) {
+    return null;
+  }
+  const bootstrapOptions = {
+    ...resolved.options,
+    ...options.force !== void 0 ? { force: options.force } : {},
+    ...options.waitForConsent ? { waitForConsent: options.waitForConsent } : {}
+  };
+  try {
+    const pixel = await bootstrapBemonyPixel(bootstrapOptions);
+    return { pixel, source: resolved.source };
+  } catch (error) {
+    if (error instanceof BemonyBootstrapError) {
+      throw error;
+    }
+    throw new BemonyBootstrapError(
+      error instanceof Error ? error.message : "Auto-init falhou",
+      "AUTO_INIT_FAILED",
+      error
+    );
+  }
+}
+export {
+  BEMONY_FORBIDDEN_DATA_ATTRIBUTES,
+  BEMONY_GLOBAL_BUNDLE_FILENAME,
+  BEMONY_PIXEL_DESTROYED_EVENT,
+  BEMONY_PIXEL_ERROR_EVENT,
+  BEMONY_PIXEL_INITIALIZING_EVENT,
+  BEMONY_PIXEL_READY_EVENT,
+  SCRIPT_SELECTOR as BEMONY_PIXEL_SCRIPT_SELECTOR,
+  BemonyBootstrapError,
+  bootstrapBemonyPixel,
+  destroyBootstrappedBemonyPixel,
+  getBootstrappedBemonyPixel,
+  getBootstrappedBemonyPixelPending,
+  installBemonyPixelAutoInit,
+  isAutoInitEnabledFromAttr,
+  isBemonyGlobalBundleSrc,
+  mergeBemonyPixelOptions,
+  parseBemonyScriptAttributes,
+  parseBooleanAttr,
+  resolveAutoInitConfig,
+  resolveBemonyExecutingScript
+};
+//# sourceMappingURL=index.esm.js.map