shopkit-analytics 1.0.1 → 1.0.3

package/dist/index.js

@@ -32,9 +32,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/events/publisher.ts
-function publishEvent(event) {
+function publishEvent(event, params) {
   try {
-    eventPublisher.publish(event);
+    eventPublisher.publish(event, params);
   } catch (error) {
     console.error("Error in publishEvent helper:", error);
   }
@@ -75,19 +75,24 @@ var init_publisher = __esm({
       /**
        * Publish an event to all subscribers
        * @param event The event to publish
+       * @param params Optional adapter-specific parameters
        */
-      publish(event) {
+      publish(event, params) {
         try {
           console.log("EventPublisher: Received event", {
             type: event.type,
-            data: event
+            data: event,
+            params
           });
           const eventWithTimestamp = !event.timestamp ? { ...event, timestamp: Date.now() } : event;
-          console.log("EventPublisher: Number of subscribers:", this.subscribers.length);
+          console.log(
+            "EventPublisher: Number of subscribers:",
+            this.subscribers.length
+          );
           for (const subscriber of this.subscribers) {
             try {
               console.log("EventPublisher: Notifying subscriber");
-              subscriber(eventWithTimestamp);
+              subscriber(eventWithTimestamp, params);
               console.log("EventPublisher: Subscriber notified successfully");
             } catch (error) {
               console.error("EventPublisher: Error in subscriber:", error);
@@ -196,18 +201,19 @@ var init_subscriber = __esm({
       /**
        * Handle an event by forwarding it to all enabled adapters
        * @param event The event to handle
+       * @param params Optional adapter-specific parameters
        */
-      handleEvent(event) {
-        console.log("Handling event:", event.type);
+      handleEvent(event, params) {
+        console.log("Handling event:", event.type, "with params:", params);
         if (!this.initialized) {
           console.log("Subscriber not initialized, queueing event");
-          this.eventQueue.push(event);
+          this.eventQueue.push({ event, params });
           return;
         }
         for (const adapter of this.adapters) {
           if (adapter.isEnabled()) {
             console.log(`Forwarding event to adapter: ${adapter.name}`);
-            adapter.trackEvent(event).catch((error) => {
+            adapter.trackEvent(event, params).catch((error) => {
               console.error(
                 `Error tracking event in adapter "${adapter.name}":`,
                 error
@@ -226,8 +232,8 @@ var init_subscriber = __esm({
           return;
         }
         console.log(`Processing ${this.eventQueue.length} queued events.`);
-        for (const event of this.eventQueue) {
-          this.handleEvent(event);
+        for (const { event, params } of this.eventQueue) {
+          this.handleEvent(event, params);
         }
         this.eventQueue = [];
       }
@@ -261,11 +267,13 @@ __export(src_exports, {
   DEFAULT_CURRENCY: () => DEFAULT_CURRENCY,
   EventNames: () => EventNames,
   EventType: () => EventType,
+  FacebookCAPIService: () => FacebookCAPIService,
   GoogleAdapter: () => GoogleAdapter,
-  HARDCODED_HANDLE: () => HARDCODED_HANDLE,
   KwikCheckoutAdapter: () => KwikCheckoutAdapter,
   KwikPassAdapter: () => KwikPassAdapter,
   MoengageAdapter: () => MoengageAdapter,
+  PRIMA_EXPERIMENT_COOKIES: () => PRIMA_EXPERIMENT_COOKIES,
+  PRIMA_EXPERIMENT_COOKIE_NAMES: () => PRIMA_EXPERIMENT_COOKIE_NAMES,
   PixelAdapter: () => PixelAdapter,
   PostHogAdapter: () => PostHogAdapter,
   ShopifyAdapter: () => ShopifyAdapter,
@@ -273,13 +281,18 @@ __export(src_exports, {
   captureAffiliateParams: () => captureAffiliateParams,
   clearAffiliateParams: () => clearAffiliateParams,
   createAdapterLogger: () => createAdapterLogger,
+  createFacebookCAPIService: () => createFacebookCAPIService,
   createLogger: () => createLogger,
   default: () => ShopkitAnalytics_default,
   eventPublisher: () => eventPublisher,
   eventSubscriber: () => eventSubscriber,
+  generateEventId: () => generateEventId,
   getAffiliateParams: () => getAffiliateParams,
   getAffiliateSource: () => getAffiliateSource,
+  getBrowserInfo: () => getBrowserInfo,
+  getExperimentParams: () => getExperimentParams,
   hasAffiliateData: () => hasAffiliateData,
+  hasExperimentData: () => hasExperimentData,
   initTracking: () => initTracking,
   initializeEventTracking: () => initializeEventTracking,
   logger: () => logger,
@@ -295,7 +308,14 @@ var import_react3 = require("react");
 var import_hydrogen_react2 = require("@shopify/hydrogen-react");
 
 // src/logger/index.ts
-var import_pino = __toESM(require("pino"));
+var LOG_LEVELS = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60
+};
 var NoOpLogger = class _NoOpLogger {
   trace() {
   }
@@ -313,92 +333,109 @@ var NoOpLogger = class _NoOpLogger {
     return new _NoOpLogger();
   }
 };
-var PinoLogger = class _PinoLogger {
-  constructor(logger2) {
-    this.logger = logger2;
+var UniversalLogger = class _UniversalLogger {
+  constructor(config, bindings = {}) {
+    this.config = config;
+    this.bindings = bindings;
+  }
+  shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[this.config.level];
+  }
+  formatMessage(level, message, args, error) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const name = this.config.name;
+    let logMessage = this.config.prettyPrint ? `[${timestamp}] ${level.toUpperCase()} [${name}]: ${message}` : JSON.stringify({
+      timestamp,
+      level,
+      name,
+      message,
+      ...this.bindings,
+      ...args.length > 0 && { args },
+      ...error && {
+        error: { message: error.message, stack: error.stack }
+      }
+    });
+    if (this.config.prettyPrint && args.length > 0) {
+      logMessage += ` ${args.map(
+        (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
+      ).join(" ")}`;
+    }
+    if (this.config.prettyPrint && error) {
+      logMessage += ` Error: ${error.message}`;
+      if (error.stack) {
+        logMessage += `
+${error.stack}`;
+      }
+    }
+    return this.redactSensitiveData(logMessage);
+  }
+  redactSensitiveData(message) {
+    let redactedMessage = message;
+    for (const field of this.config.redact) {
+      const regex = new RegExp(`"${field}"\\s*:\\s*"[^"]*"`, "gi");
+      redactedMessage = redactedMessage.replace(
+        regex,
+        `"${field}":"[REDACTED]"`
+      );
+    }
+    return redactedMessage;
+  }
+  log(level, message, args, error) {
+    if (!this.shouldLog(level)) return;
+    const formattedMessage = this.formatMessage(level, message, args, error);
+    switch (level) {
+      case "trace":
+        console.trace(formattedMessage);
+        break;
+      case "debug":
+        console.debug(formattedMessage);
+        break;
+      case "info":
+        console.info(formattedMessage);
+        break;
+      case "warn":
+        console.warn(formattedMessage);
+        break;
+      case "error":
+      case "fatal":
+        console.error(formattedMessage);
+        break;
+    }
   }
   trace(message, ...args) {
-    this.logger.trace({ args }, message);
+    this.log("trace", message, args);
   }
   debug(message, ...args) {
-    this.logger.debug({ args }, message);
+    this.log("debug", message, args);
   }
   info(message, ...args) {
-    this.logger.info({ args }, message);
+    this.log("info", message, args);
   }
   warn(message, ...args) {
-    this.logger.warn({ args }, message);
+    this.log("warn", message, args);
   }
   error(message, error, ...args) {
-    this.logger.error({ error, args }, message);
+    this.log("error", message, args, error);
   }
   fatal(message, error, ...args) {
-    this.logger.fatal({ error, args }, message);
+    this.log("fatal", message, args, error);
   }
   child(bindings) {
-    return new _PinoLogger(this.logger.child(bindings));
+    return new _UniversalLogger(this.config, { ...this.bindings, ...bindings });
   }
 };
 function createLogger(config = {}) {
-  const {
-    level = "info",
-    enabled = true,
-    name = "@shopkit/analytics",
-    prettyPrint = false,
-    redact = []
-  } = config;
-  if (!enabled) {
-    return new NoOpLogger();
-  }
-  const pinoConfig = {
-    name,
-    level,
-    redact,
-    browser: {
-      asObject: true,
-      serialize: true,
-      write: {
-        trace: (o) => console.trace(formatBrowserLog(o)),
-        debug: (o) => console.debug(formatBrowserLog(o)),
-        info: (o) => console.info(formatBrowserLog(o)),
-        warn: (o) => console.warn(formatBrowserLog(o)),
-        error: (o) => console.error(formatBrowserLog(o)),
-        fatal: (o) => console.error(formatBrowserLog(o))
-      }
-    }
+  const fullConfig = {
+    level: config.level || "info",
+    enabled: config.enabled !== false,
+    name: config.name || "@shopkit/analytics",
+    prettyPrint: config.prettyPrint || false,
+    redact: config.redact || []
   };
-  if (prettyPrint && typeof window === "undefined") {
-    pinoConfig.transport = {
-      target: "pino-pretty",
-      options: {
-        colorize: true,
-        translateTime: "HH:MM:ss Z",
-        ignore: "pid,hostname"
-      }
-    };
-  }
-  const pinoLogger = (0, import_pino.default)(pinoConfig);
-  return new PinoLogger(pinoLogger);
-}
-function formatBrowserLog(logObj) {
-  const { level, time, msg, name, args, error, ...rest } = logObj;
-  let message = `[${name}] ${msg}`;
-  if (args && args.length > 0) {
-    message += ` ${args.map(
-      (arg) => typeof arg === "object" ? JSON.stringify(arg) : String(arg)
-    ).join(" ")}`;
-  }
-  if (error) {
-    message += ` Error: ${error.message}`;
-    if (error.stack) {
-      message += `
-${error.stack}`;
-    }
-  }
-  if (Object.keys(rest).length > 0) {
-    message += ` ${JSON.stringify(rest)}`;
+  if (!fullConfig.enabled) {
+    return new NoOpLogger();
   }
-  return message;
+  return new UniversalLogger(fullConfig);
 }
 var logger = createLogger({
   enabled: true,
@@ -410,6 +447,43 @@ function createAdapterLogger(adapterName, config = {}) {
   return baseLogger.child({ adapter: adapterName });
 }
 
+// src/experiment/constants.ts
+var PRIMA_EXPERIMENT_COOKIES = {
+  HOME: "_prima_pr_ab_home",
+  COLLECTION: "_prima_pr_ab_collection",
+  PRODUCT: "_prima_pr_ab_product"
+};
+var PRIMA_EXPERIMENT_COOKIE_NAMES = Object.values(
+  PRIMA_EXPERIMENT_COOKIES
+);
+
+// src/experiment/experiment-tracker.ts
+function getCookie(name) {
+  if (typeof document === "undefined") return null;
+  const value = `; ${document.cookie}`;
+  const parts = value.split(`; ${name}=`);
+  if (parts.length === 2) {
+    return parts.pop()?.split(";").shift() || null;
+  }
+  return null;
+}
+function getExperimentParams() {
+  return {
+    [PRIMA_EXPERIMENT_COOKIES.HOME]: getCookie(PRIMA_EXPERIMENT_COOKIES.HOME),
+    [PRIMA_EXPERIMENT_COOKIES.COLLECTION]: getCookie(
+      PRIMA_EXPERIMENT_COOKIES.COLLECTION
+    ),
+    [PRIMA_EXPERIMENT_COOKIES.PRODUCT]: getCookie(
+      PRIMA_EXPERIMENT_COOKIES.PRODUCT
+    )
+  };
+}
+function hasExperimentData() {
+  return PRIMA_EXPERIMENT_COOKIE_NAMES.some(
+    (cookieName) => getCookie(cookieName) !== null
+  );
+}
+
 // src/adapters/base-adapter.ts
 var BaseAdapter = class {
   /**
@@ -447,6 +521,38 @@ var BaseAdapter = class {
   isEnabled() {
     return this.initialized;
   }
+  /**
+   * Extract adapter-specific parameters for this adapter
+   * @param params The adapter parameters object
+   * @returns Adapter-specific parameters or empty object
+   */
+  getAdapterParams(params) {
+    return params?.[this.name] || {};
+  }
+  /**
+   * Get custom event name or fall back to default
+   * @param params The adapter parameters object
+   * @param defaultName The default event name to use
+   * @returns Custom event name or default
+   */
+  getEventName(params, defaultName) {
+    const adapterParams = this.getAdapterParams(params);
+    return adapterParams.event_name || defaultName;
+  }
+  /**
+   * Merge standard event data with adapter-specific parameters
+   * @param params The adapter parameters object
+   * @param standardData The standard event data
+   * @returns Merged data with adapter-specific overrides
+   */
+  mergeEventData(standardData, params) {
+    const adapterParams = this.getAdapterParams(params);
+    const { event_name, ...customParams } = adapterParams;
+    return {
+      ...standardData,
+      ...customParams
+    };
+  }
   /**
    * Get a configuration value
    * @param key The configuration key
@@ -463,6 +569,21 @@ var BaseAdapter = class {
   getAffiliateParams() {
     return null;
   }
+  /**
+   * Get experiment parameters from cookies
+   * @returns Experiment parameters
+   */
+  getExperimentParams() {
+    try {
+      return getExperimentParams();
+    } catch (error) {
+      return {
+        _prima_pr_ab_home: null,
+        _prima_pr_ab_collection: null,
+        _prima_pr_ab_product: null
+      };
+    }
+  }
   /**
    * Enhance event parameters with affiliate data
    * @param params The original parameters
@@ -477,12 +598,23 @@ var BaseAdapter = class {
       ...affiliateParams
     };
   }
+  /**
+   * Enhance event parameters with experiment data
+   * @param params The original parameters
+   * @returns Parameters enhanced with experiment data
+   */
+  enhanceWithExperimentParams(params) {
+    const experimentParams = this.getExperimentParams();
+    return {
+      ...params,
+      experiment: experimentParams
+    };
+  }
 };
 
 // src/types.ts
 var EventType = /* @__PURE__ */ ((EventType2) => {
   EventType2["PRODUCT_VIEW"] = "product_view";
-  EventType2["STARTED_ORDER"] = "started_order";
   EventType2["PAGE_VIEW"] = "page_view";
   EventType2["BUTTON_CLICK"] = "button_click";
   EventType2["FORM_SUBMISSION"] = "form_submission";
@@ -495,11 +627,6 @@ var EventType = /* @__PURE__ */ ((EventType2) => {
   EventType2["CHECKOUT_STARTED"] = "checkout_started";
   EventType2["CHECKOUT_COMPLETED"] = "checkout_completed";
   EventType2["SEARCH"] = "search";
-  EventType2["CART_PAGE_LAND"] = "cart_page_land";
-  EventType2["CLOSE_CART"] = "close_cart";
-  EventType2["QUANTITY_CHANGE"] = "quantity_change";
-  EventType2["FILTER_APPLIED"] = "filter_applied";
-  EventType2["NEWSLETTER_SUBSCRIPTION"] = "newsletter_subscription";
   EventType2["USER_SIGNUP"] = "user_signup";
   EventType2["USER_LOGIN"] = "user_login";
   EventType2["CUSTOM"] = "custom";
@@ -510,25 +637,11 @@ var EventType = /* @__PURE__ */ ((EventType2) => {
   EventType2["FORM_START"] = "form_start";
   EventType2["ADD_PAYMENT_INFO"] = "add_payment_info";
   EventType2["CART_VIEWED"] = "cart_viewed";
-  EventType2["PAGES_SCREENS_PER_SESSION"] = "pages_screens_per_session";
   EventType2["VIEW_CONTENT"] = "view_content";
   EventType2["PURCHASE"] = "purchase";
   EventType2["VIEW_SEARCH_RESULTS"] = "view_search_results";
   EventType2["ORDER_PLACED"] = "order_placed";
   EventType2["BEGIN_CHECKOUT"] = "begin_checkout";
-  EventType2["ITEM_PURCHASED"] = "item_purchased";
-  EventType2["UPDATE_CART"] = "update_cart";
-  EventType2["CUSTOMER_REGISTERED"] = "customer_registered";
-  EventType2["CUSTOMER_LOGGED_IN"] = "customer_logged_in";
-  EventType2["SHOPIFY_CHECKOUT_UPDATED"] = "shopify_checkout_updated";
-  EventType2["SHOPIFY_ABANDONED_CHECKOUT"] = "shopify_abandoned_checkout";
-  EventType2["SHOPIFY_ORDER_FULFILLED"] = "shopify_order_fulfilled";
-  EventType2["SHOPIFY_CHECKOUT_STARTED"] = "shopify_checkout_started";
-  EventType2["SHOPIFY_ADD_TO_CART"] = "shopify_add_to_cart";
-  EventType2["SHOPIFY_REMOVED_FROM_CART"] = "shopify_removed_from_cart";
-  EventType2["SHOPIFY_UPDATE_CART"] = "shopify_update_cart";
-  EventType2["SPINFORM_RESULT"] = "spinform_result";
-  EventType2["COUPON_COPIED"] = "coupon_copied";
   EventType2["STARTED_CHECKOUT_GK"] = "started_checkout_gk";
   EventType2["MOBILE_ADDED_GK"] = "mobile_added_gk";
   EventType2["ADDRESS_SELECTED_GK"] = "address_selected_gk";
@@ -539,19 +652,60 @@ var EventType = /* @__PURE__ */ ((EventType2) => {
   EventType2["ORDER_COMPLETED"] = "order_completed";
   EventType2["PIN_CODE_ADDED_GK"] = "pin_code_added_gk";
   EventType2["ADDRESS_ADDED_GK"] = "address_added_gk";
-  EventType2["KP_MP_PHONE_NUMBER_LOGGED_IN"] = "kp_mp_phone_number_logged_in";
-  EventType2["KP_PHONE_NUMBER_LOGGED_IN"] = "kp_phone_number_logged_in";
-  EventType2["KP_MP_SHOPIFY_LOGGED_IN"] = "kp_mp_shopify_logged_in";
-  EventType2["KP_MP_SUCCESSFULLY_LOGGED_OUT"] = "kp_mp_successfully_logged_out";
-  EventType2["KP_WHATSAPP_LOGGED_IN"] = "kp_whatsapp_logged_in";
-  EventType2["KP_MP_TRUECALLER_LOGGED_IN"] = "kp_mp_truecaller_logged_in";
-  EventType2["KP_MP_WHATSAPP_LOGGED_IN"] = "kp_mp_whatsapp_logged_in";
-  EventType2["KP_TRUECALLER_LOGGED_IN"] = "kp_truecaller_logged_in";
-  EventType2["KP_SHOPIFY_LOGGED_IN"] = "kp_shopify_logged_in";
-  EventType2["KP_SUCCESSFULLY_LOGGED_OUT"] = "kp_successfully_logged_out";
   return EventType2;
 })(EventType || {});
 
+// src/utils/event-id.ts
+function generateEventId(eventType) {
+  const timestamp = Date.now();
+  const randomString = Math.random().toString(36).substring(2, 8);
+  return `${timestamp}_${randomString}_${eventType}`;
+}
+function getBrowserInfo() {
+  if (typeof window === "undefined") {
+    return {};
+  }
+  const userAgent = navigator.userAgent;
+  const fbc = getFacebookClickId();
+  const fbp = getFacebookBrowserId();
+  return {
+    clientUserAgent: userAgent,
+    fbc,
+    fbp
+  };
+}
+function getFacebookClickId() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  const urlParams = new URLSearchParams(window.location.search);
+  const fbclid = urlParams.get("fbclid");
+  if (fbclid) {
+    return `fb.1.${Date.now()}.${fbclid}`;
+  }
+  const cookies = document.cookie.split(";");
+  for (const cookie of cookies) {
+    const [name, value] = cookie.trim().split("=");
+    if (name === "_fbc") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function getFacebookBrowserId() {
+  if (typeof window === "undefined") {
+    return void 0;
+  }
+  const cookies = document.cookie.split(";");
+  for (const cookie of cookies) {
+    const [name, value] = cookie.trim().split("=");
+    if (name === "_fbp") {
+      return value;
+    }
+  }
+  return void 0;
+}
+
 // src/adapters/pixel-adapter.ts
 var PixelAdapter = class extends BaseAdapter {
   constructor(config) {
@@ -577,18 +731,34 @@ var PixelAdapter = class extends BaseAdapter {
       );
       return;
     }
-    const pixelId = this.getConfig("pixelId");
     this.logger.info("Successfully initialized", { pixelId: "***" });
     this.initialized = true;
   }
   /**
    * Track an event with Facebook Pixel
    * @param event The event to track
+   * @param adapterParams Optional adapter-specific parameters
    */
-  async trackEvent(event) {
+  async trackEvent(event, adapterParams) {
+    if (!event.eventId) {
+      event.eventId = generateEventId(event.type);
+    }
+    this.logger.debug("Tracking event", {
+      eventType: event.type,
+      eventId: event.eventId
+    });
+    await this.trackClientSide(event, adapterParams);
+    if (this.getConfig("enableCAPI", true)) {
+      await this.trackServerSide(event);
+    }
+  }
+  /**
+   * Track event on client-side (browser pixel)
+   */
+  async trackClientSide(event, adapterParams) {
     if (!this.initialized || typeof window === "undefined" || !window.fbq) {
       this.logger.warn(
-        "Cannot track event, adapter not initialized or fbq not available",
+        "Cannot track client-side event, adapter not initialized or fbq not available",
         {
           eventType: event.type,
           initialized: this.initialized,
@@ -598,55 +768,96 @@ var PixelAdapter = class extends BaseAdapter {
       );
       return;
     }
-    this.logger.debug("Tracking event", { eventType: event.type });
     switch (event.type) {
       case "page_view" /* PAGE_VIEW */:
-        this.trackPageView(event);
+        this.trackPageView(event, adapterParams);
         break;
       case "view_content" /* VIEW_CONTENT */:
-        this.trackViewContent(event);
+        this.trackViewContent(event, adapterParams);
         break;
       case "product_view" /* PRODUCT_VIEW */:
-        this.trackProductView(event);
+        this.trackProductView(event, adapterParams);
         break;
       case "add_to_cart" /* ADD_TO_CART */:
-        this.trackAddToCart(event);
+        this.trackAddToCart(event, adapterParams);
         break;
       case "checkout_started" /* CHECKOUT_STARTED */:
-        this.trackCheckoutStarted(event);
+        this.trackCheckoutStarted(event, adapterParams);
         break;
       case "checkout_completed" /* CHECKOUT_COMPLETED */:
-        this.trackCheckoutCompleted(event);
+        this.trackCheckoutCompleted(event, adapterParams);
         break;
       case "purchase" /* PURCHASE */:
-        this.trackPurchase(event);
+        this.trackPurchase(event, adapterParams);
         break;
       case "add_payment_info" /* ADD_PAYMENT_INFO */:
-        this.trackAddPaymentInfo(event);
+        this.trackAddPaymentInfo(event, adapterParams);
         break;
       case "search" /* SEARCH */:
-        this.trackSearch(event);
+        this.trackSearch(event, adapterParams);
         break;
       default:
         this.logger.debug("Unhandled event type", { eventType: event.type });
         break;
     }
   }
+  /**
+   * Track event on server-side (CAPI) as backup
+   */
+  async trackServerSide(event) {
+    try {
+      const browserInfo = getBrowserInfo();
+      const payload = {
+        events: [event],
+        userInfo: browserInfo
+      };
+      const response = await fetch("/api/events", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        throw new Error(`Server-side tracking failed: ${response.status}`);
+      }
+      this.logger.debug(
+        `FB Pixel: Server-side backup sent for event ${event.type}`
+      );
+    } catch (error) {
+      this.logger.error(
+        `FB Pixel: Server-side backup failed for event ${event.type}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
   /**
    * Track a page view event
    * @param event The page view event
    */
-  trackPageView(event) {
-    const params = this.enhanceWithAffiliateParams({});
-    window.fbq?.("track", "PageView", params);
-    this.logger.debug("PageView event tracked", { params });
+  trackPageView(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "PageView");
+    const affiliateParams = this.enhanceWithAffiliateParams({});
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    if (event.eventId) {
+      window.fbq?.("track", eventName, enhancedParams, {
+        eventID: event.eventId
+      });
+    } else {
+      window.fbq?.("track", eventName, enhancedParams);
+    }
+    this.logger.debug("PageView event tracked", {
+      eventName,
+      params: enhancedParams
+    });
   }
   /**
    * Track a product view event
    * @param event The product view event
    */
-  trackProductView(event) {
-    const params = {
+  trackProductView(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "ViewContent");
+    const baseParams = {
       content_type: "product_group",
       content_ids: [event.productId],
       content_name: event.productName,
@@ -654,34 +865,56 @@ var PixelAdapter = class extends BaseAdapter {
       value: event.price,
       currency: event.currency || "INR"
     };
-    window.fbq?.(
-      "track",
-      "ViewContent",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    if (event.eventId) {
+      window.fbq?.("track", eventName, enhancedParams, {
+        eventID: event.eventId
+      });
+    } else {
+      window.fbq?.("track", eventName, enhancedParams);
+    }
+    this.logger.debug("ProductView event tracked", {
+      eventName,
+      params: enhancedParams
+    });
   }
   /**
    * Track an add to cart event
    * @param event The add to cart event
    */
-  trackAddToCart(event) {
-    const params = {
+  trackAddToCart(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "AddToCart");
+    const baseParams = {
       content_type: "product_group",
       content_ids: [event.productId],
       content_name: event.productName,
       value: event.price,
       currency: event.currency || "INR"
     };
-    const enhancedParams = this.enhanceWithAffiliateParams(params);
-    window.fbq?.("track", "AddToCart", enhancedParams);
-    this.logger.debug("AddToCart event tracked", { params: enhancedParams });
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    if (event.eventId) {
+      window.fbq?.("track", eventName, enhancedParams, {
+        eventID: event.eventId
+      });
+    } else {
+      window.fbq?.("track", eventName, enhancedParams);
+    }
+    this.logger.debug("AddToCart event tracked", {
+      eventName,
+      params: enhancedParams
+    });
   }
   /**
    * Track a checkout started event
    * @param event The checkout started event
    */
-  trackCheckoutStarted(event) {
-    const params = {
+  trackCheckoutStarted(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "InitiateCheckout");
+    const baseParams = {
       content_ids: event.items.map((item) => item.productId),
       content_type: "product_group",
       value: event.cartValue,
@@ -693,18 +926,28 @@ var PixelAdapter = class extends BaseAdapter {
         item_price: item.price
       }))
     };
-    window.fbq?.(
-      "track",
-      "InitiateCheckout",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    if (event.eventId) {
+      window.fbq?.("track", eventName, enhancedParams, {
+        eventID: event.eventId
+      });
+    } else {
+      window.fbq?.("track", eventName, enhancedParams);
+    }
+    this.logger.debug("CheckoutStarted event tracked", {
+      eventName,
+      params: enhancedParams
+    });
   }
   /**
    * Track a checkout completed event
    * @param event The checkout completed event
    */
-  trackCheckoutCompleted(event) {
-    const params = {
+  trackCheckoutCompleted(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "Purchase");
+    const baseParams = {
       value: event.cartValue,
       currency: event.currency || "INR",
       content_type: "product_group",
@@ -716,26 +959,54 @@ var PixelAdapter = class extends BaseAdapter {
         item_price: item.price
       }))
     };
-    window.fbq?.("track", "Purchase", this.enhanceWithAffiliateParams(params));
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    if (event.eventId) {
+      window.fbq?.("track", eventName, enhancedParams, {
+        eventID: event.eventId
+      });
+    } else {
+      window.fbq?.("track", eventName, enhancedParams);
+    }
+    this.logger.debug("CheckoutCompleted event tracked", {
+      eventName,
+      params: enhancedParams
+    });
   }
   /**
    * Track a search event
    * @param event The search event
    */
-  trackSearch(event) {
-    const params = {
+  trackSearch(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "Search");
+    const baseParams = {
       search_string: event.searchTerm,
       content_category: "product",
       content_ids: event.content_ids || []
     };
-    window.fbq?.("track", "Search", this.enhanceWithAffiliateParams(params));
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    if (event.eventId) {
+      window.fbq?.("track", eventName, enhancedParams, {
+        eventID: event.eventId
+      });
+    } else {
+      window.fbq?.("track", eventName, enhancedParams);
+    }
+    this.logger.debug("Search event tracked", {
+      eventName,
+      params: enhancedParams
+    });
   }
   /**
    * Track an add payment info event
    * @param event The add payment info event
    */
-  trackAddPaymentInfo(event) {
-    const params = {
+  trackAddPaymentInfo(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "AddPaymentInfo");
+    const baseParams = {
       value: event.cartValue,
       currency: event.currency || "INR",
       content_type: "product_group",
@@ -747,18 +1018,28 @@ var PixelAdapter = class extends BaseAdapter {
       })),
       payment_type: event.paymentType || ""
     };
-    window.fbq?.(
-      "track",
-      "AddPaymentInfo",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    if (event.eventId) {
+      window.fbq?.("track", eventName, enhancedParams, {
+        eventID: event.eventId
+      });
+    } else {
+      window.fbq?.("track", eventName, enhancedParams);
+    }
+    this.logger.debug("AddPaymentInfo event tracked", {
+      eventName,
+      params: enhancedParams
+    });
   }
   /**
    * Track a view content event
    * @param event The view content event
    */
-  trackViewContent(event) {
-    const params = {
+  trackViewContent(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "ViewContent");
+    const baseParams = {
       content_type: event.content_type || "product",
       content_ids: event.content_ids || [],
       content_name: event.content_name || "",
@@ -766,18 +1047,28 @@ var PixelAdapter = class extends BaseAdapter {
       value: event.value || 0,
       currency: event.currency || "INR"
     };
-    window.fbq?.(
-      "track",
-      "ViewContent",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    if (event.eventId) {
+      window.fbq?.("track", eventName, enhancedParams, {
+        eventID: event.eventId
+      });
+    } else {
+      window.fbq?.("track", eventName, enhancedParams);
+    }
+    this.logger.debug("ViewContent event tracked", {
+      eventName,
+      params: enhancedParams
+    });
   }
   /**
    * Track a purchase event
    * @param event The purchase event
    */
-  trackPurchase(event) {
-    const params = {
+  trackPurchase(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "Purchase");
+    const baseParams = {
       value: event.value,
       currency: event.currency || "INR",
       content_type: event.content_type || "product_group",
@@ -785,15 +1076,20 @@ var PixelAdapter = class extends BaseAdapter {
       num_items: event.num_items || 1,
       contents: event.contents || []
     };
-    window.fbq?.("track", "Purchase", this.enhanceWithAffiliateParams(params));
-  }
-  /**
-   * Convert an event to Facebook Pixel parameters
-   * @param event The event to convert
-   */
-  eventToParams(event) {
-    const { type, timestamp, ...params } = event;
-    return this.enhanceWithAffiliateParams(params);
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    if (event.eventId) {
+      window.fbq?.("track", eventName, enhancedParams, {
+        eventID: event.eventId
+      });
+    } else {
+      window.fbq?.("track", eventName, enhancedParams);
+    }
+    this.logger.debug("Purchase event tracked", {
+      eventName,
+      params: enhancedParams
+    });
   }
 };
 
@@ -842,8 +1138,9 @@ var GoogleAdapter = class extends BaseAdapter {
   /**
    * Track an event with Google Analytics
    * @param event The event to track
+   * @param adapterParams Optional adapter-specific parameters
    */
-  async trackEvent(event) {
+  async trackEvent(event, adapterParams) {
     this.logger.debug("Attempting to track event", {
       initialized: this.initialized,
       hasWindow: typeof window !== "undefined",
@@ -869,76 +1166,94 @@ var GoogleAdapter = class extends BaseAdapter {
     });
     switch (event.type) {
       case "page_view" /* PAGE_VIEW */:
-        this.trackPageView(event, measurementId);
+        this.trackPageView(
+          event,
+          measurementId,
+          adapterParams
+        );
         break;
       case "user_engagement" /* USER_ENGAGEMENT */:
-        this.trackUserEngagement();
+        this.trackUserEngagement(adapterParams);
         break;
       case "session_start" /* SESSION_START */:
-        this.trackSessionStart();
+        this.trackSessionStart(adapterParams);
         break;
       case "first_visit" /* FIRST_VISIT */:
-        this.trackFirstVisit();
+        this.trackFirstVisit(adapterParams);
         break;
       case "view_item" /* VIEW_ITEM */:
-        this.trackViewItem(event);
+        this.trackViewItem(event, adapterParams);
         break;
       case "viewed_product" /* VIEWED_PRODUCT */:
-        this.trackViewedProduct(event);
+        this.trackViewedProduct(event, adapterParams);
         break;
       case "checkout_payment" /* CHECKOUT_PAYMENT */:
-        this.trackCheckoutPayment(event);
+        this.trackCheckoutPayment(
+          event,
+          adapterParams
+        );
         break;
       case "scroll" /* SCROLL */:
-        this.trackScroll();
+        this.trackScroll(adapterParams);
         break;
       case "add_to_cart" /* ADD_TO_CART */:
-      case "shopify_add_to_cart" /* SHOPIFY_ADD_TO_CART */:
-        this.trackAddToCart(event);
+        this.trackAddToCart(event, adapterParams);
         break;
       case "form_start" /* FORM_START */:
-        this.trackFormStart();
+        this.trackFormStart(adapterParams);
         break;
       case "checkout_started" /* CHECKOUT_STARTED */:
-        this.trackCheckoutStarted(event);
+        this.trackCheckoutStarted(
+          event,
+          adapterParams
+        );
         break;
       case "form_submission" /* FORM_SUBMISSION */:
-        this.trackFormSubmission(event);
+        this.trackFormSubmission(event, adapterParams);
         break;
       case "search" /* SEARCH */:
-        this.trackSearch(event);
+        this.trackSearch(event, adapterParams);
         break;
       case "checkout_completed" /* CHECKOUT_COMPLETED */:
-        this.trackCheckoutCompleted(event);
+        this.trackCheckoutCompleted(
+          event,
+          adapterParams
+        );
         break;
       case "add_payment_info" /* ADD_PAYMENT_INFO */:
-        this.trackAddPaymentInfo(event);
+        this.trackAddPaymentInfo(event, adapterParams);
         break;
       case "view_content" /* VIEW_CONTENT */:
-        this.trackViewContent(event);
+        this.trackViewContent(event, adapterParams);
         break;
       case "purchase" /* PURCHASE */:
-        this.trackPurchase(event);
+        this.trackPurchase(event, adapterParams);
         break;
       case "view_search_results" /* VIEW_SEARCH_RESULTS */:
-        this.trackViewSearchResults(event);
+        this.trackViewSearchResults(
+          event,
+          adapterParams
+        );
         break;
       case "order_placed" /* ORDER_PLACED */:
-        this.trackOrderPlaced(event);
+        this.trackOrderPlaced(event, adapterParams);
         break;
       case "begin_checkout" /* BEGIN_CHECKOUT */:
-        this.trackBeginCheckout(event);
+        this.trackBeginCheckout(event, adapterParams);
         break;
       case "custom" /* CUSTOM */:
-        this.trackCustomEvent(event);
+        this.trackCustomEvent(event, adapterParams);
         break;
       default: {
-        const params = this.eventToParams(event);
-        window.gtag(
-          "event",
-          event.type,
-          this.enhanceWithAffiliateParams(params)
+        const eventName = this.getEventName(adapterParams, event.type);
+        const baseParams = this.eventToParams(event);
+        const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+        const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+        const enhancedParams = this.mergeEventData(
+          experimentParams,
+          adapterParams
         );
+        window.gtag("event", eventName, enhancedParams);
         break;
       }
     }
@@ -948,8 +1263,9 @@ var GoogleAdapter = class extends BaseAdapter {
    * @param event The page view event
    * @param measurementId The Google Analytics measurement ID
    */
-  trackPageView(event, measurementId) {
-    const params = {
+  trackPageView(event, measurementId, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "page_view");
+    const baseParams = {
       page_path: event.path,
       page_title: event.title || document.title,
       page_location: event.page_location || window.location.href,
@@ -972,14 +1288,14 @@ var GoogleAdapter = class extends BaseAdapter {
       user_properties: event.user_properties,
       session_engaged: event.session_engaged
     };
-    window.gtag?.(
-      "event",
-      "page_view",
-      this.enhanceWithAffiliateParams(params)
-    );
-  }
-  trackUserEngagement() {
-    const params = {
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
+  }
+  trackUserEngagement(adapterParams) {
+    const eventName = this.getEventName(adapterParams, "user_engagement");
+    const baseParams = {
       batch_ordering_id: "",
       batch_page_id: "",
       campaign: "",
@@ -996,14 +1312,14 @@ var GoogleAdapter = class extends BaseAdapter {
       srsltid: "",
       term: ""
     };
-    window.gtag?.(
-      "event",
-      "user_engagement",
-      this.enhanceWithAffiliateParams(params)
-    );
-  }
-  trackSessionStart() {
-    const params = {
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
+  }
+  trackSessionStart(adapterParams) {
+    const eventName = this.getEventName(adapterParams, "session_start");
+    const baseParams = {
       batch_ordering_id: "",
       batch_page_id: "",
       campaign: "",
@@ -1022,14 +1338,14 @@ var GoogleAdapter = class extends BaseAdapter {
       srsltid: "",
       term: ""
     };
-    window.gtag?.(
-      "event",
-      "session_start",
-      this.enhanceWithAffiliateParams(params)
-    );
-  }
-  trackFirstVisit() {
-    const params = {
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
+  }
+  trackFirstVisit(adapterParams) {
+    const eventName = this.getEventName(adapterParams, "first_visit");
+    const baseParams = {
       batch_ordering_id: "",
       batch_page_id: "",
       campaign: "",
@@ -1050,25 +1366,26 @@ var GoogleAdapter = class extends BaseAdapter {
       page_source: "",
       page_term: ""
     };
-    window.gtag?.(
-      "event",
-      "first_visit",
-      this.enhanceWithAffiliateParams(params)
-    );
-  }
-  trackViewItem(event) {
-    window.gtag?.(
-      "event",
-      "view_item",
-      this.enhanceWithAffiliateParams({
-        currency: event.currency,
-        value: event.value,
-        items: event.items
-      })
-    );
-  }
-  trackScroll() {
-    const params = {
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
+  }
+  trackViewItem(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "view_item");
+    const baseParams = {
+      currency: event.currency,
+      value: event.value,
+      items: event.items
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
+  }
+  trackScroll(adapterParams) {
+    const eventName = this.getEventName(adapterParams, "scroll");
+    const baseParams = {
       batch_ordering_id: "",
       batch_page_id: "",
       engagement_time_msec: void 0,
@@ -1082,46 +1399,52 @@ var GoogleAdapter = class extends BaseAdapter {
       percent_scrolled: 90
       // or dynamically captured
     };
-    window.gtag?.("event", "scroll", this.enhanceWithAffiliateParams(params));
-  }
-  trackCheckoutPayment(event) {
-    window.gtag?.(
-      "event",
-      "checkout_payment",
-      this.enhanceWithAffiliateParams({
-        currency: event.currency,
-        value: event.cartValue,
-        items: event.items.map((item) => ({
-          item_id: item.productId,
-          item_name: item.productName,
-          price: item.price,
-          quantity: item.quantity
-        }))
-      })
-    );
-  }
-  trackViewedProduct(event) {
-    window.gtag?.(
-      "event",
-      "viewed_product",
-      this.enhanceWithAffiliateParams({
-        currency: event.currency,
-        value: event.price,
-        items: [
-          {
-            item_id: event.productId,
-            item_name: event.productName,
-            price: event.price,
-            currency: event.currency
-          }
-        ],
-        view_duration: event.viewDuration
-      })
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
+  }
+  trackCheckoutPayment(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "checkout_payment");
+    const baseParams = {
+      currency: event.currency,
+      value: event.cartValue,
+      items: event.items.map((item) => ({
+        item_id: item.productId,
+        item_name: item.productName,
+        price: item.price,
+        quantity: item.quantity
+      }))
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
+  }
+  trackViewedProduct(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "viewed_product");
+    const baseParams = {
+      currency: event.currency,
+      value: event.price,
+      items: [
+        {
+          item_id: event.productId,
+          item_name: event.productName,
+          price: event.price,
+          currency: event.currency
+        }
+      ],
+      view_duration: event.viewDuration
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
   }
-  trackAddToCart(event) {
+  trackAddToCart(event, adapterParams) {
     this.logger.debug("Processing add_to_cart event", { event });
-    const params = {
+    const eventName = this.getEventName(adapterParams, "add_to_cart");
+    const baseParams = {
       currency: event.currency || "INR",
       value: event.price * (event.quantity || 1),
       // Calculate total value
@@ -1147,14 +1470,18 @@ var GoogleAdapter = class extends BaseAdapter {
       user_id: event.user_id,
       user_properties: event.user_properties
     };
-    const enhancedParams = this.enhanceWithAffiliateParams(params);
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
     this.logger.debug("Sending add_to_cart event to gtag", {
+      eventName,
       params: enhancedParams
     });
-    window.gtag?.("event", "add_to_cart", enhancedParams);
+    window.gtag?.("event", eventName, enhancedParams);
   }
-  trackFormStart() {
-    const params = {
+  trackFormStart(adapterParams) {
+    const eventName = this.getEventName(adapterParams, "form_start");
+    const baseParams = {
       batch_ordering_id: "",
       batch_page_id: "",
       engagement_time_msec: void 0,
@@ -1172,14 +1499,14 @@ var GoogleAdapter = class extends BaseAdapter {
       page_referrer: document.referrer,
       page_title: document.title
     };
-    window.gtag?.(
-      "event",
-      "form_start",
-      this.enhanceWithAffiliateParams(params)
-    );
-  }
-  trackCheckoutStarted(event) {
-    const params = {
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
+  }
+  trackCheckoutStarted(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "begin_checkout");
+    const baseParams = {
       batch_ordering_id: "",
       batch_page_id: "",
       currency: event.currency || "INR",
@@ -1202,14 +1529,14 @@ var GoogleAdapter = class extends BaseAdapter {
         item_variant: item.variant
       }))
     };
-    window.gtag?.(
-      "event",
-      "begin_checkout",
-      this.enhanceWithAffiliateParams(params)
-    );
-  }
-  trackFormSubmission(event) {
-    const params = {
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
+  }
+  trackFormSubmission(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "form_submit");
+    const baseParams = {
       batch_ordering_id: "",
       batch_page_id: "",
       engagement_time_msec: void 0,
@@ -1223,14 +1550,14 @@ var GoogleAdapter = class extends BaseAdapter {
       page_referrer: document.referrer,
       page_title: document.title
     };
-    window.gtag?.(
-      "event",
-      "form_submit",
-      this.enhanceWithAffiliateParams(params)
-    );
-  }
-  trackSearch(event) {
-    const params = {
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
+  }
+  trackSearch(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "search");
+    const baseParams = {
       batch_ordering_id: "",
       batch_page_id: "",
       engagement_time_msec: void 0,
@@ -1242,14 +1569,18 @@ var GoogleAdapter = class extends BaseAdapter {
       page_title: document.title,
       search_term: event.searchTerm
     };
-    window.gtag?.("event", "search", this.enhanceWithAffiliateParams(params));
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
   }
   /**
    * Track a checkout completed event
    * @param event The checkout completed event
    */
-  trackCheckoutCompleted(event) {
-    const params = {
+  trackCheckoutCompleted(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "purchase");
+    const baseParams = {
       transaction_id: event.orderId,
       currency: event.currency || "INR",
       value: event.cartValue,
@@ -1261,22 +1592,30 @@ var GoogleAdapter = class extends BaseAdapter {
         item_variant: item.variant
       }))
     };
-    window.gtag?.("event", "purchase", this.enhanceWithAffiliateParams(params));
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
   }
   /**
    * Track a custom event
    * @param event The custom event
    */
-  trackCustomEvent(event) {
-    const params = event.properties || {};
-    window.gtag?.("event", event.name, this.enhanceWithAffiliateParams(params));
+  trackCustomEvent(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, event.name);
+    const baseParams = event.properties || {};
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
   }
   /**
    * Track an add payment info event
    * @param event The add payment info event
    */
-  trackAddPaymentInfo(event) {
-    const params = {
+  trackAddPaymentInfo(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "add_payment_info");
+    const baseParams = {
       currency: event.currency || "INR",
       value: event.cartValue,
       payment_type: event.paymentType || "",
@@ -1288,18 +1627,18 @@ var GoogleAdapter = class extends BaseAdapter {
         item_variant: item.variant
       }))
     };
-    window.gtag?.(
-      "event",
-      "add_payment_info",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
   }
   /**
    * Track a view content event
    * @param event The view content event
    */
-  trackViewContent(event) {
-    const params = {
+  trackViewContent(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "view_item");
+    const baseParams = {
       currency: event.currency || "USD",
       value: event.value || 0,
       items: event.items?.map((item) => ({
@@ -1328,18 +1667,18 @@ var GoogleAdapter = class extends BaseAdapter {
       user_id: event.user_id,
       user_properties: event.user_properties
     };
-    window.gtag?.(
-      "event",
-      "view_item",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
   }
   /**
    * Track a purchase event
    * @param event The purchase event
    */
-  trackPurchase(event) {
-    const params = {
+  trackPurchase(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "purchase");
+    const baseParams = {
       transaction_id: event.transaction_id,
       value: event.value,
       currency: event.currency || "USD",
@@ -1372,14 +1711,18 @@ var GoogleAdapter = class extends BaseAdapter {
       user_id: event.user_id,
       user_properties: event.user_properties
     };
-    window.gtag?.("event", "purchase", this.enhanceWithAffiliateParams(params));
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
   }
   /**
    * Track a view search results event
    * @param event The view search results event
    */
-  trackViewSearchResults(event) {
-    const params = {
+  trackViewSearchResults(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "view_search_results");
+    const baseParams = {
       search_term: event.search_term,
       // GA4-specific parameters
       batch_ordering_id: event.batch_ordering_id || "",
@@ -1394,18 +1737,18 @@ var GoogleAdapter = class extends BaseAdapter {
       user_id: event.user_id,
       user_properties: event.user_properties
     };
-    window.gtag?.(
-      "event",
-      "view_search_results",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
   }
   /**
    * Track an order placed event
    * @param event The order placed event
    */
-  trackOrderPlaced(event) {
-    const params = {
+  trackOrderPlaced(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "purchase");
+    const baseParams = {
       transaction_id: event.order_id,
       value: event.total_amount,
       currency: event.currency || "USD",
@@ -1431,14 +1774,18 @@ var GoogleAdapter = class extends BaseAdapter {
       user_id: event.user_id,
       user_properties: event.user_properties
     };
-    window.gtag?.("event", "purchase", this.enhanceWithAffiliateParams(params));
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
   }
   /**
    * Track a begin checkout event
    * @param event The begin checkout event
    */
-  trackBeginCheckout(event) {
-    const params = {
+  trackBeginCheckout(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "begin_checkout");
+    const baseParams = {
       currency: event.currency || "USD",
       value: event.value || 0,
       coupon: event.coupon,
@@ -1468,11 +1815,10 @@ var GoogleAdapter = class extends BaseAdapter {
       user_id: event.user_id,
       user_properties: event.user_properties
     };
-    window.gtag?.(
-      "event",
-      "begin_checkout",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.gtag?.("event", eventName, enhancedParams);
   }
   /**
    * Convert an event to Google Analytics parameters
@@ -1480,7 +1826,8 @@ var GoogleAdapter = class extends BaseAdapter {
    */
   eventToParams(event) {
     const { type, timestamp, ...params } = event;
-    return this.enhanceWithAffiliateParams(params);
+    const affiliateParams = this.enhanceWithAffiliateParams(params);
+    return this.enhanceWithExperimentParams(affiliateParams);
   }
 };
 
@@ -1502,44 +1849,9 @@ var EventNames = {
   SEARCH: "Search",
   // User events
   USER_SIGNED_UP: "User Signed Up",
-  USER_LOGGED_IN: "User Logged In",
-  // MoEngage events
-  ITEM_PURCHASED: "Item Purchased",
-  UPDATE_CART: "Update Cart",
-  CUSTOMER_REGISTERED: "Customer Registered",
-  CUSTOMER_LOGGED_IN: "Customer Logged In",
-  SHOPIFY_CHECKOUT_UPDATED: "Shopify - Checkout Updated",
-  SHOPIFY_ABANDONED_CHECKOUT: "Shopify - Abandoned Checkout",
-  SHOPIFY_ORDER_FULFILLED: "Shopify - Order Fulfilled",
-  SHOPIFY_CHECKOUT_STARTED: "Shopify - Checkout Started",
-  SHOPIFY_ADD_TO_CART: "Shopify - Add To Cart",
-  SHOPIFY_REMOVED_FROM_CART: "Shopify - Removed From Cart",
-  SHOPIFY_UPDATE_CART: "Shopify - Update Cart",
-  SPINFORM_RESULT: "Spinform Result",
-  COUPON_COPIED: "Coupon Copied",
-  STARTED_CHECKOUT_GK: "Started Checkout GK",
-  MOBILE_ADDED_GK: "Mobile Added GK",
-  ADDRESS_SELECTED_GK: "Address Selected GK",
-  ADDRESS_COMPLETED_GK: "Address Completed GK",
-  PAYMENT_METHOD_SELECTED_GK: "Payment Method Selected GK",
-  PAYMENT_COMPLETED_GK: "Payment Completed GK",
-  ORDER_SUCCESS: "Order Success",
-  ORDER_COMPLETED: "Order Completed",
-  PIN_CODE_ADDED_GK: "PIN Code Added GK",
-  ADDRESS_ADDED_GK: "Address Added GK",
-  KP_MP_PHONE_NUMBER_LOGGED_IN: "KP MP Phone Number Logged In",
-  KP_PHONE_NUMBER_LOGGED_IN: "KP Phone Number Logged In",
-  KP_MP_SHOPIFY_LOGGED_IN: "KP MP Shopify Logged In",
-  KP_MP_SUCCESSFULLY_LOGGED_OUT: "KP MP Successfully Logged Out",
-  KP_WHATSAPP_LOGGED_IN: "KP Whatsapp Logged In",
-  KP_MP_TRUECALLER_LOGGED_IN: "KP MP Truecaller Logged In",
-  KP_MP_WHATSAPP_LOGGED_IN: "KP MP Whatsapp Logged In",
-  KP_TRUECALLER_LOGGED_IN: "KP Truecaller Logged In",
-  KP_SHOPIFY_LOGGED_IN: "KP Shopify Logged In",
-  KP_SUCCESSFULLY_LOGGED_OUT: "KP Successfully Logged Out"
+  USER_LOGGED_IN: "User Logged In"
 };
 var DEFAULT_CURRENCY = "INR";
-var HARDCODED_HANDLE = "ryze-gums";
 
 // src/adapters/moengage-adapter.ts
 var import_web_sdk = __toESM(require("@moengage/web-sdk"));
@@ -1591,8 +1903,9 @@ var MoengageAdapter = class extends BaseAdapter {
   /**
    * Track an event with MoenGage SDK
    * @param event The event to track
+   * @param adapterParams Optional adapter-specific parameters
    */
-  async trackEvent(event) {
+  async trackEvent(event, adapterParams) {
     if (!this.initialized || typeof window === "undefined" || !this.sdk) {
       this.logger.warn(
         "Cannot track event, adapter not initialized or SDK not available",
@@ -1608,106 +1921,172 @@ var MoengageAdapter = class extends BaseAdapter {
     this.logger.debug("Tracking event", { eventType: event.type });
     switch (event.type) {
       case "page_view" /* PAGE_VIEW */:
-        this.trackPageView(event);
+        this.trackPageView(event, adapterParams);
         break;
       case "button_click" /* BUTTON_CLICK */:
-        this.trackButtonClick(event);
+        this.trackButtonClick(event, adapterParams);
         break;
       case "form_submission" /* FORM_SUBMISSION */:
-        this.trackFormSubmission(event);
+        this.trackFormSubmission(event, adapterParams);
         break;
       case "product_view" /* PRODUCT_VIEW */:
-        this.trackProductView(event);
+        this.trackProductView(event, adapterParams);
         break;
       case "add_to_cart" /* ADD_TO_CART */:
-        this.trackAddToCart(event);
+        this.trackAddToCart(event, adapterParams);
         break;
       case "remove_from_cart" /* REMOVE_FROM_CART */:
-        this.trackRemoveFromCart(event);
+        this.trackRemoveFromCart(event, adapterParams);
         break;
       case "checkout_started" /* CHECKOUT_STARTED */:
-        this.trackCheckoutStarted(event);
+        this.trackCheckoutStarted(
+          event,
+          adapterParams
+        );
         break;
       case "checkout_completed" /* CHECKOUT_COMPLETED */:
-        this.trackCheckoutCompleted(event);
+        this.trackCheckoutCompleted(
+          event,
+          adapterParams
+        );
         break;
       case "search" /* SEARCH */:
-        this.trackSearch(event);
+        this.trackSearch(event, adapterParams);
         break;
       case "user_signup" /* USER_SIGNUP */:
-        this.trackUserSignup(event);
+        this.trackUserSignup(event, adapterParams);
         break;
       case "user_login" /* USER_LOGIN */:
-        this.trackUserLogin(event);
+        this.trackUserLogin(event, adapterParams);
         break;
       case "custom" /* CUSTOM */:
-        this.trackCustomEvent(event);
+        this.trackCustomEvent(event, adapterParams);
         break;
       default:
-        this.sdk.track_event(event.type, this.eventToParams(event));
+        const eventName = this.getEventName(adapterParams, event.type);
+        const baseParams = this.eventToParams(event);
+        const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+        const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+        const enhancedParams = this.mergeEventData(
+          experimentParams,
+          adapterParams
+        );
+        this.sdk.track_event(eventName, enhancedParams);
         break;
     }
   }
   /**
    * Track a page view event
    * @param event The page view event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackPageView(event) {
+  trackPageView(event, adapterParams) {
     if (!this.sdk?.track_event) {
       this.logger.warn("track_event not available for PageView event");
       return;
     }
-    const eventData = {
+    const eventName = this.getEventName(adapterParams, EventNames.PAGE_VIEWED);
+    const baseEventData = {
       page_path: event.path,
       page_title: event.title,
       page_url: window.location.href,
       referrer: event.referrer || document.referrer
     };
-    this.sdk.track_event(EventNames.PAGE_VIEWED, eventData);
-    this.logger.debug("PageView event tracked", { eventData });
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk.track_event(eventName, enhancedEventData);
+    this.logger.debug("PageView event tracked", {
+      eventName,
+      eventData: enhancedEventData
+    });
   }
   /**
    * Track a button click event
    * @param event The button click event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackButtonClick(event) {
-    this.sdk?.track_event(EventNames.BUTTON_CLICKED, {
+  trackButtonClick(event, adapterParams) {
+    const eventName = this.getEventName(
+      adapterParams,
+      EventNames.BUTTON_CLICKED
+    );
+    const baseEventData = {
       button_id: event.buttonId,
       button_text: event.buttonText,
       location: event.location
-    });
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk?.track_event(eventName, enhancedEventData);
   }
   /**
    * Track a form submission event
    * @param event The form submission event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackFormSubmission(event) {
-    this.sdk?.track_event(EventNames.FORM_SUBMITTED, {
+  trackFormSubmission(event, adapterParams) {
+    const eventName = this.getEventName(
+      adapterParams,
+      EventNames.FORM_SUBMITTED
+    );
+    const baseEventData = {
       form_id: event.formId,
       form_name: event.formName,
       success: event.success
-    });
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk?.track_event(eventName, enhancedEventData);
   }
   /**
    * Track a product view event
    * @param event The product view event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackProductView(event) {
-    this.sdk?.track_event(EventNames.PRODUCT_VIEWED, {
+  trackProductView(event, adapterParams) {
+    const eventName = this.getEventName(
+      adapterParams,
+      EventNames.PRODUCT_VIEWED
+    );
+    const baseEventData = {
       product_id: event.productId,
       product_name: event.productName,
       price: event.price,
       currency: event.currency || DEFAULT_CURRENCY,
       category: event.category
-    });
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk?.track_event(eventName, enhancedEventData);
   }
   /**
    * Track an add to cart event
    * @param event The add to cart event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackAddToCart(event) {
+  trackAddToCart(event, adapterParams) {
     const quantity = event.quantity ?? 1;
-    this.sdk?.track_event(EventNames.ADDED_TO_CART, {
+    const eventName = this.getEventName(
+      adapterParams,
+      EventNames.ADDED_TO_CART
+    );
+    const baseEventData = {
       product_id: event.productId,
       product_name: event.productName,
       price: event.price,
@@ -1715,14 +2094,26 @@ var MoengageAdapter = class extends BaseAdapter {
       quantity,
       variant: event.variant,
       total_value: event.price * quantity
-    });
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk?.track_event(eventName, enhancedEventData);
   }
   /**
    * Track a remove from cart event
    * @param event The remove from cart event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackRemoveFromCart(event) {
-    this.sdk?.track_event(EventNames.REMOVED_FROM_CART, {
+  trackRemoveFromCart(event, adapterParams) {
+    const eventName = this.getEventName(
+      adapterParams,
+      EventNames.REMOVED_FROM_CART
+    );
+    const baseEventData = {
       product_id: event.productId,
       product_name: event.productName,
       price: event.price,
@@ -1730,14 +2121,26 @@ var MoengageAdapter = class extends BaseAdapter {
       quantity: event.quantity,
       variant: event.variant,
       total_value: event.price * event.quantity
-    });
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk?.track_event(eventName, enhancedEventData);
   }
   /**
    * Track a checkout started event
    * @param event The checkout started event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackCheckoutStarted(event) {
-    this.sdk?.track_event(EventNames.CHECKOUT_STARTED, {
+  trackCheckoutStarted(event, adapterParams) {
+    const eventName = this.getEventName(
+      adapterParams,
+      EventNames.CHECKOUT_STARTED
+    );
+    const baseEventData = {
       cart_value: event.cartValue,
       currency: event.currency || DEFAULT_CURRENCY,
       item_count: event.itemCount,
@@ -1748,14 +2151,26 @@ var MoengageAdapter = class extends BaseAdapter {
         quantity: item.quantity,
         variant: item.variant
       }))
-    });
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk?.track_event(eventName, enhancedEventData);
   }
   /**
    * Track a checkout completed event
    * @param event The checkout completed event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackCheckoutCompleted(event) {
-    this.sdk?.track_event(EventNames.PURCHASE_COMPLETED, {
+  trackCheckoutCompleted(event, adapterParams) {
+    const eventName = this.getEventName(
+      adapterParams,
+      EventNames.PURCHASE_COMPLETED
+    );
+    const baseEventData = {
       order_id: event.orderId,
       cart_value: event.cartValue,
       currency: event.currency || DEFAULT_CURRENCY,
@@ -1767,28 +2182,56 @@ var MoengageAdapter = class extends BaseAdapter {
         quantity: item.quantity,
         variant: item.variant
       }))
-    });
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk?.track_event(eventName, enhancedEventData);
   }
   /**
    * Track a search event
    * @param event The search event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackSearch(event) {
-    this.sdk?.track_event(EventNames.SEARCH, {
+  trackSearch(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, EventNames.SEARCH);
+    const baseEventData = {
       search_term: event.searchTerm,
       results_count: event.resultsCount
-    });
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk?.track_event(eventName, enhancedEventData);
   }
   /**
    * Track a user signup event
    * @param event The user signup event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackUserSignup(event) {
-    this.sdk?.track_event(EventNames.USER_SIGNED_UP, {
+  trackUserSignup(event, adapterParams) {
+    const eventName = this.getEventName(
+      adapterParams,
+      EventNames.USER_SIGNED_UP
+    );
+    const baseEventData = {
       user_id: event.userId,
       method: event.method,
       success: event.success
-    });
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk?.track_event(eventName, enhancedEventData);
     if (event.userId && this.getConfig("enableUserIdentification", true)) {
       this.sdk?.add_unique_user_id(event.userId);
     }
@@ -1796,13 +2239,25 @@ var MoengageAdapter = class extends BaseAdapter {
   /**
    * Track a user login event
    * @param event The user login event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackUserLogin(event) {
-    this.sdk?.track_event(EventNames.USER_LOGGED_IN, {
+  trackUserLogin(event, adapterParams) {
+    const eventName = this.getEventName(
+      adapterParams,
+      EventNames.USER_LOGGED_IN
+    );
+    const baseEventData = {
       user_id: event.userId,
       method: event.method,
       success: event.success
-    });
+    };
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk?.track_event(eventName, enhancedEventData);
     if (event.userId && this.getConfig("enableUserIdentification", true)) {
       this.sdk?.add_unique_user_id(event.userId);
     }
@@ -1810,9 +2265,18 @@ var MoengageAdapter = class extends BaseAdapter {
   /**
    * Track a custom event
    * @param event The custom event
-   */
-  trackCustomEvent(event) {
-    this.sdk?.track_event(event.name, event.properties);
+   * @param adapterParams Optional adapter-specific parameters
+   */
+  trackCustomEvent(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, event.name);
+    const baseEventData = event.properties || {};
+    const affiliateParams = this.enhanceWithAffiliateParams(baseEventData);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedEventData = this.mergeEventData(
+      experimentParams,
+      adapterParams
+    );
+    this.sdk?.track_event(eventName, enhancedEventData);
   }
   /**
    * Convert an event to MoenGage parameters
@@ -1899,8 +2363,9 @@ var PostHogAdapter = class extends BaseAdapter {
   /**
    * Track an event with PostHog
    * @param event The event to track
+   * @param adapterParams Optional adapter-specific parameters
    */
-  async trackEvent(event) {
+  async trackEvent(event, adapterParams) {
     if (!this.initialized || typeof window === "undefined" || !window.posthog) {
       this.logger.warn(
         "Cannot track event, adapter not initialized or posthog not available",
@@ -1916,74 +2381,84 @@ var PostHogAdapter = class extends BaseAdapter {
     this.logger.debug("Tracking event", { eventType: event.type });
     switch (event.type) {
       case "page_view" /* PAGE_VIEW */:
-        this.trackPageView(event);
+        this.trackPageView(event, adapterParams);
         break;
       case "product_view" /* PRODUCT_VIEW */:
-        this.trackProductView(event);
+        this.trackProductView(event, adapterParams);
         break;
       case "add_to_cart" /* ADD_TO_CART */:
-        this.trackAddToCart(event);
+        this.trackAddToCart(event, adapterParams);
         break;
       case "checkout_started" /* CHECKOUT_STARTED */:
-        this.trackCheckoutStarted(event);
+        this.trackCheckoutStarted(event, adapterParams);
         break;
       case "checkout_completed" /* CHECKOUT_COMPLETED */:
-        this.trackCheckoutCompleted(event);
+        this.trackCheckoutCompleted(event, adapterParams);
         break;
       case "add_payment_info" /* ADD_PAYMENT_INFO */:
-        this.trackAddPaymentInfo(event);
+        this.trackAddPaymentInfo(event, adapterParams);
         break;
       case "search" /* SEARCH */:
-        this.trackSearch(event);
+        this.trackSearch(event, adapterParams);
         break;
       default:
-        const params = this.eventToParams(event);
-        window.posthog?.capture(
-          event.type,
-          this.enhanceWithAffiliateParams(params)
+        const eventName = this.getEventName(adapterParams, event.type);
+        const baseParams = this.eventToParams(event);
+        const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+        const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+        const enhancedParams = this.mergeEventData(
+          experimentParams,
+          adapterParams
         );
+        window.posthog?.capture(eventName, enhancedParams);
         break;
     }
   }
   /**
    * Track a page view event
    * @param event The page view event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackPageView(event) {
-    const params = {
+  trackPageView(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "$pageview");
+    const baseParams = {
       path: event.path,
       title: event.title,
       referrer: event.referrer
     };
-    window.posthog?.capture(
-      "$pageview",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.posthog?.capture(eventName, enhancedParams);
   }
   /**
    * Track a product view event
    * @param event The product view event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackProductView(event) {
-    const params = {
+  trackProductView(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "product_viewed");
+    const baseParams = {
       product_id: event.productId,
       product_name: event.productName,
       category: event.category,
       price: event.price,
       currency: event.currency || "INR"
     };
-    window.posthog?.capture(
-      "product_viewed",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.posthog?.capture(eventName, enhancedParams);
   }
   /**
    * Track an add to cart event
    * @param event The add to cart event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackAddToCart(event) {
+  trackAddToCart(event, adapterParams) {
     this.logger.debug("Handling ADD_TO_CART event", { event });
-    const params = {
+    const eventName = this.getEventName(adapterParams, "add_to_cart");
+    const baseParams = {
       product_id: event.productId,
       product_name: event.productName,
       price: event.price,
@@ -1991,23 +2466,28 @@ var PostHogAdapter = class extends BaseAdapter {
       quantity: event.quantity,
       variant: event.variant
     };
-    this.logger.debug("Sending to PostHog with params", { params });
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    this.logger.debug("Sending to PostHog with params", {
+      eventName,
+      params: enhancedParams
+    });
     if (!window.posthog) {
       this.logger.error("window.posthog is not available");
       return;
     }
-    window.posthog.capture(
-      "add_to_cart",
-      this.enhanceWithAffiliateParams(params)
-    );
+    window.posthog.capture(eventName, enhancedParams);
     this.logger.debug("Event sent to PostHog successfully");
   }
   /**
    * Track a checkout started event
    * @param event The checkout started event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackCheckoutStarted(event) {
-    const params = {
+  trackCheckoutStarted(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "checkout_started");
+    const baseParams = {
       cart_value: event.cartValue,
       currency: event.currency || "INR",
       item_count: event.itemCount,
@@ -2019,17 +2499,19 @@ var PostHogAdapter = class extends BaseAdapter {
         variant: item.variant
       }))
     };
-    window.posthog?.capture(
-      "checkout_started",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.posthog?.capture(eventName, enhancedParams);
   }
   /**
    * Track a checkout completed event
    * @param event The checkout completed event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackCheckoutCompleted(event) {
-    const params = {
+  trackCheckoutCompleted(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "purchase");
+    const baseParams = {
       order_id: event.orderId,
       cart_value: event.cartValue,
       currency: event.currency || "INR",
@@ -2042,29 +2524,36 @@ var PostHogAdapter = class extends BaseAdapter {
         variant: item.variant
       }))
     };
-    window.posthog?.capture(
-      "purchase",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.posthog?.capture(eventName, enhancedParams);
   }
   /**
    * Track a search event
    * @param event The search event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackSearch(event) {
-    const params = {
+  trackSearch(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "search");
+    const baseParams = {
       search_term: event.searchTerm,
       results_count: event.resultsCount,
       content_ids: event.content_ids
     };
-    window.posthog?.capture("search", this.enhanceWithAffiliateParams(params));
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.posthog?.capture(eventName, enhancedParams);
   }
   /**
    * Track an add payment info event
    * @param event The add payment info event
+   * @param adapterParams Optional adapter-specific parameters
    */
-  trackAddPaymentInfo(event) {
-    const params = {
+  trackAddPaymentInfo(event, adapterParams) {
+    const eventName = this.getEventName(adapterParams, "add_payment_info");
+    const baseParams = {
       cart_value: event.cartValue,
       currency: event.currency || "INR",
       payment_type: event.paymentType,
@@ -2077,10 +2566,10 @@ var PostHogAdapter = class extends BaseAdapter {
         variant: item.variant
       }))
     };
-    window.posthog?.capture(
-      "add_payment_info",
-      this.enhanceWithAffiliateParams(params)
-    );
+    const affiliateParams = this.enhanceWithAffiliateParams(baseParams);
+    const experimentParams = this.enhanceWithExperimentParams(affiliateParams);
+    const enhancedParams = this.mergeEventData(experimentParams, adapterParams);
+    window.posthog?.capture(eventName, enhancedParams);
   }
   /**
    * Convert an event to PostHog parameters
@@ -2199,43 +2688,62 @@ var ShopifyAdapter = class extends BaseAdapter {
       shopId: `gid://shopify/Shop/${this.shopId}`,
       currency: this.currency,
       acceptedLanguage: DEFAULT_LANGUAGE,
-      ...this.enhanceWithAffiliateParams({})
+      ...this.enhanceWithExperimentParams(this.enhanceWithAffiliateParams({}))
     };
   }
   /**
    * Track an event using Shopify Analytics
    */
-  async trackEvent(event) {
+  async trackEvent(event, adapterParams) {
     if (!this.initialized || typeof window === "undefined") {
       this.logger.warn(
         "Shopify Analytics not initialized or not in browser environment"
       );
       return;
     }
+    const params = this.getAdapterParams(adapterParams);
+    const customEventName = this.getEventName(params, event.type);
     this.logger.debug("Processing Shopify Analytics event", {
       eventType: event.type,
-      eventData: event
+      customEventName,
+      eventData: event,
+      adapterParams: params
     });
+    const affiliateParams = this.enhanceWithAffiliateParams(event);
+    const enhancedEvent = this.enhanceWithExperimentParams(affiliateParams);
     try {
       switch (event.type) {
         case "page_view" /* PAGE_VIEW */:
-          this.sendPageView(import_hydrogen_react.AnalyticsEventName.PAGE_VIEW);
-          this.logger.debug("Sent PAGE_VIEW event to Shopify Analytics");
+          const pageViewPayload = this.mergeEventData(enhancedEvent, params);
+          this.sendPageView(import_hydrogen_react.AnalyticsEventName.PAGE_VIEW, pageViewPayload);
+          this.logger.debug("Sent PAGE_VIEW event to Shopify Analytics", {
+            payload: pageViewPayload
+          });
           break;
         case "view_content" /* VIEW_CONTENT */:
-          this.sendPageView(import_hydrogen_react.AnalyticsEventName.PRODUCT_VIEW);
-          this.logger.debug("Sent PRODUCT_VIEW event to Shopify Analytics");
+          const viewContentPayload = this.mergeEventData(enhancedEvent, params);
+          this.sendPageView(
+            import_hydrogen_react.AnalyticsEventName.PRODUCT_VIEW,
+            viewContentPayload
+          );
+          this.logger.debug("Sent PRODUCT_VIEW event to Shopify Analytics", {
+            payload: viewContentPayload
+          });
           break;
         case "add_to_cart" /* ADD_TO_CART */:
-          this.trackAddToCart(event);
+          const addToCartPayload = this.mergeEventData(enhancedEvent, params);
+          this.trackAddToCart(addToCartPayload);
           break;
         case "checkout_started" /* CHECKOUT_STARTED */:
         case "begin_checkout" /* BEGIN_CHECKOUT */:
-          this.sendPageView(import_hydrogen_react.AnalyticsEventName.PAGE_VIEW, {
-            pageType: "checkout"
-          });
+          const checkoutPayload = this.mergeEventData(
+            { ...enhancedEvent, pageType: "checkout" },
+            params
+          );
+          this.sendPageView(import_hydrogen_react.AnalyticsEventName.PAGE_VIEW, checkoutPayload);
           this.logger.debug(
-            "Sent checkout PAGE_VIEW event to Shopify Analytics"
+            "Sent checkout PAGE_VIEW event to Shopify Analytics",
+            { payload: checkoutPayload }
           );
           break;
         default:
@@ -2361,8 +2869,10 @@ var KwikPassAdapter = class extends BaseAdapter {
   }
   /**
    * Track an event using KwikPass
+   * @param event The event to track
+   * @param adapterParams Optional adapter-specific parameters
    */
-  async trackEvent(event) {
+  async trackEvent(event, adapterParams) {
     if (!this.initialized || typeof window === "undefined") {
       this.logger.warn(
         "KwikPass adapter not initialized or not in browser environment"
@@ -2375,18 +2885,19 @@ var KwikPassAdapter = class extends BaseAdapter {
       });
       return;
     }
+    const affiliateParams = this.enhanceWithAffiliateParams(event);
+    const enhancedEvent = this.enhanceWithExperimentParams(affiliateParams);
     try {
       this.logger.debug("Processing event", { eventType: event.type });
-      const enhancedEvent = this.enhanceWithAffiliateParams(event);
       switch (event.type) {
         case "product_view" /* PRODUCT_VIEW */:
-          this.trackProductView(enhancedEvent);
+          this.trackProductView(enhancedEvent, adapterParams);
           break;
         case "collection_view" /* COLLECTION_VIEW */:
-          this.trackCollectionView(enhancedEvent);
+          this.trackCollectionView(enhancedEvent, adapterParams);
           break;
         case "page_view" /* PAGE_VIEW */:
-          this.trackPageView(enhancedEvent);
+          this.trackPageView(enhancedEvent, adapterParams);
           break;
         default:
           this.logger.debug("Event not supported", { eventType: event.type });
@@ -2401,55 +2912,71 @@ var KwikPassAdapter = class extends BaseAdapter {
   /**
    * Send event to KwikPass platform
    */
-  sendKwikPassEvent(type, eventData) {
-    this.logger.debug(`Sending ${type}`, { eventData });
+  sendKwikPassEvent(type, eventData, adapterParams) {
+    const customEventType = this.getEventName(adapterParams, type);
+    const enhancedEventData = this.mergeEventData(eventData, adapterParams);
+    this.logger.debug(`Sending ${customEventType}`, {
+      eventData: enhancedEventData
+    });
     if (typeof window !== "undefined") {
       const customEvent = new CustomEvent(`page_view_kp`, {
         detail: {
-          type,
-          detail: eventData
+          type: customEventType,
+          detail: enhancedEventData
         }
       });
       window.dispatchEvent(customEvent);
-      this.logger.debug(`${type} sent successfully`);
+      this.logger.debug(`${customEventType} sent successfully`);
     }
   }
   /**
-   * Track product view event
+   * Track collection view event
    */
-  trackCollectionView(event) {
-    this.sendKwikPassEvent("collection", {
-      product_id: event.productId,
-      product_name: event.productName,
-      price: event.price,
-      currency: event.currency,
-      category: event.category,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackCollectionView(event, adapterParams) {
+    this.sendKwikPassEvent(
+      "collection",
+      {
+        product_id: event.productId,
+        product_name: event.productName,
+        price: event.price,
+        currency: event.currency,
+        category: event.category,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
-   * Track collection view event
+   * Track product view event
    */
-  trackProductView(event) {
-    this.sendKwikPassEvent("product", {
-      product_id: event.productId,
-      product_name: event.productName,
-      price: event.price,
-      currency: event.currency,
-      category: event.category,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackProductView(event, adapterParams) {
+    this.sendKwikPassEvent(
+      "product",
+      {
+        product_id: event.productId,
+        product_name: event.productName,
+        price: event.price,
+        currency: event.currency,
+        category: event.category,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track page view event
    */
-  trackPageView(event) {
-    this.sendKwikPassEvent("other", {
-      path: event.path,
-      title: event.title,
-      referrer: event.referrer,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackPageView(event, adapterParams) {
+    this.sendKwikPassEvent(
+      "other",
+      {
+        path: event.path,
+        title: event.title,
+        referrer: event.referrer,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
 };
 
@@ -2483,8 +3010,10 @@ var KwikCheckoutAdapter = class extends BaseAdapter {
   }
   /**
    * Track an event using GoKwik
+   * @param event The event to track
+   * @param adapterParams Optional adapter-specific parameters
    */
-  async trackEvent(event) {
+  async trackEvent(event, adapterParams) {
     if (!this.initialized || typeof window === "undefined") {
       this.logger.warn(
         "GoKwik adapter not initialized or not in browser environment"
@@ -2493,49 +3022,50 @@ var KwikCheckoutAdapter = class extends BaseAdapter {
     }
     try {
       this.logger.debug("Processing event", { eventType: event.type });
-      const enhancedEvent = this.enhanceWithAffiliateParams(event);
+      const affiliateEnhanced = this.enhanceWithAffiliateParams(event);
+      const enhancedEvent = this.enhanceWithExperimentParams(affiliateEnhanced);
       switch (event.type) {
         case "started_checkout_gk" /* STARTED_CHECKOUT_GK */:
-          this.trackStartedCheckoutGK(enhancedEvent);
+          this.trackStartedCheckoutGK(enhancedEvent, adapterParams);
           break;
         case "mobile_added_gk" /* MOBILE_ADDED_GK */:
-          this.trackMobileAddedGK(enhancedEvent);
+          this.trackMobileAddedGK(enhancedEvent, adapterParams);
           break;
         case "address_selected_gk" /* ADDRESS_SELECTED_GK */:
-          this.trackAddressSelectedGK(enhancedEvent);
+          this.trackAddressSelectedGK(enhancedEvent, adapterParams);
           break;
         case "address_completed_gk" /* ADDRESS_COMPLETED_GK */:
-          this.trackAddressCompletedGK(enhancedEvent);
+          this.trackAddressCompletedGK(enhancedEvent, adapterParams);
           break;
         case "address_added_gk" /* ADDRESS_ADDED_GK */:
-          this.trackAddressAddedGK(enhancedEvent);
+          this.trackAddressAddedGK(enhancedEvent, adapterParams);
           break;
         case "pin_code_added_gk" /* PIN_CODE_ADDED_GK */:
-          this.trackPinCodeAddedGK(enhancedEvent);
+          this.trackPinCodeAddedGK(enhancedEvent, adapterParams);
           break;
         case "payment_method_selected_gk" /* PAYMENT_METHOD_SELECTED_GK */:
-          this.trackPaymentMethodSelectedGK(enhancedEvent);
+          this.trackPaymentMethodSelectedGK(enhancedEvent, adapterParams);
           break;
         case "payment_completed_gk" /* PAYMENT_COMPLETED_GK */:
-          this.trackPaymentCompletedGK(enhancedEvent);
+          this.trackPaymentCompletedGK(enhancedEvent, adapterParams);
           break;
         case "order_success" /* ORDER_SUCCESS */:
-          this.trackOrderSuccess(enhancedEvent);
+          this.trackOrderSuccess(enhancedEvent, adapterParams);
           break;
         case "order_completed" /* ORDER_COMPLETED */:
-          this.trackOrderCompleted(enhancedEvent);
+          this.trackOrderCompleted(enhancedEvent, adapterParams);
           break;
         case "cart_viewed" /* CART_VIEWED */:
-          this.trackCartViewed(enhancedEvent);
+          this.trackCartViewed(enhancedEvent, adapterParams);
           break;
         case "checkout_started" /* CHECKOUT_STARTED */:
-          this.trackCheckoutStarted(enhancedEvent);
+          this.trackCheckoutStarted(enhancedEvent, adapterParams);
           break;
         case "checkout_completed" /* CHECKOUT_COMPLETED */:
-          this.trackCheckoutCompleted(enhancedEvent);
+          this.trackCheckoutCompleted(enhancedEvent, adapterParams);
           break;
         case "add_payment_info" /* ADD_PAYMENT_INFO */:
-          this.trackAddPaymentInfo(enhancedEvent);
+          this.trackAddPaymentInfo(enhancedEvent, adapterParams);
           break;
         default:
           this.logger.debug("Event not supported", { eventType: event.type });
@@ -2550,171 +3080,233 @@ var KwikCheckoutAdapter = class extends BaseAdapter {
   /**
    * Send event to GoKwik platform
    */
-  sendGoKwikEvent(eventName, eventData) {
-    this.logger.debug(`Sending ${eventName}`, { eventData });
+  sendGoKwikEvent(eventName, eventData, adapterParams) {
+    const customEventName = this.getEventName(adapterParams, eventName);
+    const enhancedEventData = this.mergeEventData(eventData, adapterParams);
+    this.logger.debug(`Sending ${customEventName}`, {
+      eventData: enhancedEventData
+    });
     if (typeof window !== "undefined" && window.gokwikSdk) {
       try {
-        window.gokwikSdk.track?.(eventName, eventData);
-        this.logger.debug(`${eventName} sent via SDK successfully`);
+        window.gokwikSdk.track?.(customEventName, enhancedEventData);
+        this.logger.debug(`${customEventName} sent via SDK successfully`);
       } catch (error) {
         this.logger.error(
-          `Error sending GoKwik event ${eventName} via SDK`,
+          `Error sending GoKwik event ${customEventName} via SDK`,
           error
         );
       }
     } else {
       if (typeof window !== "undefined") {
-        const customEvent = new CustomEvent(`gokwik_${eventName}`, {
-          detail: eventData
+        const customEvent = new CustomEvent(`gokwik_${customEventName}`, {
+          detail: enhancedEventData
         });
         window.dispatchEvent(customEvent);
-        this.logger.debug(`${eventName} sent via custom event successfully`);
+        this.logger.debug(
+          `${customEventName} sent via custom event successfully`
+        );
       }
     }
   }
   /**
    * Track started checkout GK event
    */
-  trackStartedCheckoutGK(event) {
-    this.sendGoKwikEvent("started_checkout", {
-      cart_value: event.cartValue,
-      currency: event.currency,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackStartedCheckoutGK(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "started_checkout",
+      {
+        cart_value: event.cartValue,
+        currency: event.currency,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track mobile added GK event
    */
-  trackMobileAddedGK(event) {
-    this.sendGoKwikEvent("mobile_added", {
-      mobile: event.mobile,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackMobileAddedGK(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "mobile_added",
+      {
+        mobile: event.mobile,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track address selected GK event
    */
-  trackAddressSelectedGK(event) {
-    this.sendGoKwikEvent("address_selected", {
-      address_id: event.addressId,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackAddressSelectedGK(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "address_selected",
+      {
+        address_id: event.addressId,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track address completed GK event
    */
-  trackAddressCompletedGK(event) {
-    this.sendGoKwikEvent("address_completed", {
-      address_id: event.addressId,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackAddressCompletedGK(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "address_completed",
+      {
+        address_id: event.addressId,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track address added GK event
    */
-  trackAddressAddedGK(event) {
-    this.sendGoKwikEvent("address_added", {
-      address_id: event.addressId,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackAddressAddedGK(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "address_added",
+      {
+        address_id: event.addressId,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track PIN code added GK event
    */
-  trackPinCodeAddedGK(event) {
-    this.sendGoKwikEvent("pin_code_added", {
-      pin_code: event.pinCode,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackPinCodeAddedGK(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "pin_code_added",
+      {
+        pin_code: event.pinCode,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track payment method selected GK event
    */
-  trackPaymentMethodSelectedGK(event) {
-    this.sendGoKwikEvent("payment_method_selected", {
-      payment_method: event.paymentMethod,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackPaymentMethodSelectedGK(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "payment_method_selected",
+      {
+        payment_method: event.paymentMethod,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track payment completed GK event
    */
-  trackPaymentCompletedGK(event) {
-    this.sendGoKwikEvent("payment_completed", {
-      amount: event.amount,
-      currency: event.currency,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackPaymentCompletedGK(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "payment_completed",
+      {
+        amount: event.amount,
+        currency: event.currency,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track order success event
    */
-  trackOrderSuccess(event) {
-    this.sendGoKwikEvent("order_success", {
-      order_id: event.orderId,
-      amount: event.amount,
-      currency: event.currency,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackOrderSuccess(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "order_success",
+      {
+        order_id: event.orderId,
+        amount: event.amount,
+        currency: event.currency,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track order completed event
    */
-  trackOrderCompleted(event) {
-    this.sendGoKwikEvent("order_completed", {
-      order_id: event.orderId,
-      amount: event.amount,
-      currency: event.currency,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackOrderCompleted(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "order_completed",
+      {
+        order_id: event.orderId,
+        amount: event.amount,
+        currency: event.currency,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track cart viewed event
    */
-  trackCartViewed(event) {
-    this.sendGoKwikEvent("cart_viewed", {
-      cart_id: event.cartId,
-      products: event.products,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackCartViewed(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "cart_viewed",
+      {
+        cart_id: event.cartId,
+        products: event.products,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track checkout started event
    */
-  trackCheckoutStarted(event) {
-    this.sendGoKwikEvent("checkout_started", {
-      cart_value: event.cartValue,
-      currency: event.currency,
-      item_count: event.itemCount,
-      items: event.items,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackCheckoutStarted(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "checkout_started",
+      {
+        cart_value: event.cartValue,
+        currency: event.currency,
+        item_count: event.itemCount,
+        items: event.items,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track checkout completed event
    */
-  trackCheckoutCompleted(event) {
-    this.sendGoKwikEvent("checkout_completed", {
-      order_id: event.orderId,
-      cart_value: event.cartValue,
-      currency: event.currency,
-      item_count: event.itemCount,
-      items: event.items,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackCheckoutCompleted(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "checkout_completed",
+      {
+        order_id: event.orderId,
+        cart_value: event.cartValue,
+        currency: event.currency,
+        item_count: event.itemCount,
+        items: event.items,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
   /**
    * Track add payment info event
    */
-  trackAddPaymentInfo(event) {
-    this.sendGoKwikEvent("add_payment_info", {
-      cart_value: event.cartValue,
-      currency: event.currency,
-      item_count: event.itemCount,
-      payment_type: event.paymentType,
-      items: event.items,
-      timestamp: event.timestamp || Date.now()
-    });
+  trackAddPaymentInfo(event, adapterParams) {
+    this.sendGoKwikEvent(
+      "add_payment_info",
+      {
+        cart_value: event.cartValue,
+        currency: event.currency,
+        item_count: event.itemCount,
+        payment_type: event.paymentType,
+        items: event.items,
+        timestamp: event.timestamp || Date.now()
+      },
+      adapterParams
+    );
   }
 };
 
@@ -3233,6 +3825,155 @@ var ShopkitAnalytics_default = ShopkitAnalytics;
 // src/events/index.ts
 init_publisher();
 init_subscriber();
+
+// src/services/facebook-capi.ts
+var FacebookCAPIService = class {
+  constructor(config) {
+    this.baseUrl = "https://graph.facebook.com/v18.0";
+    this.config = config;
+  }
+  /**
+   * Send events to Facebook CAPI
+   */
+  async sendEvents(events, userInfo) {
+    if (!this.config.accessToken || !this.config.pixelId) {
+      console.warn("Facebook CAPI: Missing access token or pixel ID");
+      return;
+    }
+    const supportedEvents = events.filter(
+      (event) => this.isSupportedEvent(event.type)
+    );
+    if (supportedEvents.length === 0) {
+      console.log("Facebook CAPI: No supported events to send");
+      return;
+    }
+    const capiEvents = supportedEvents.map(
+      (event) => this.convertToFacebookEvent(event, userInfo)
+    );
+    const payload = {
+      data: capiEvents,
+      test_event_code: this.config.testEventCode
+    };
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/${this.config.pixelId}/events?access_token=${this.config.accessToken}`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(payload)
+        }
+      );
+      if (!response.ok) {
+        const errorData = await response.json();
+        console.error("Facebook CAPI Error:", errorData);
+        throw new Error(`Facebook CAPI request failed: ${response.status}`);
+      }
+      const result = await response.json();
+      console.log("Facebook CAPI: Events sent successfully", {
+        events_received: result.events_received,
+        messages: result.messages
+      });
+    } catch (error) {
+      console.error("Facebook CAPI: Failed to send events", error);
+      throw error;
+    }
+  }
+  /**
+   * Check if event type is supported (matches PixelAdapter implementation)
+   */
+  isSupportedEvent(eventType) {
+    return [
+      "page_view" /* PAGE_VIEW */,
+      "product_view" /* PRODUCT_VIEW */,
+      "add_to_cart" /* ADD_TO_CART */,
+      "search" /* SEARCH */
+    ].includes(eventType);
+  }
+  /**
+   * Convert internal event to Facebook CAPI event format
+   * Only handles events implemented in PixelAdapter
+   */
+  convertToFacebookEvent(event, userInfo) {
+    const baseEvent = {
+      event_name: this.mapEventName(event.type),
+      event_time: Math.floor((event.timestamp || Date.now()) / 1e3),
+      event_id: event.eventId,
+      action_source: "website",
+      user_data: userInfo ? {
+        client_ip_address: userInfo.clientIpAddress,
+        client_user_agent: userInfo.clientUserAgent,
+        fbc: userInfo.fbc,
+        fbp: userInfo.fbp
+      } : void 0
+    };
+    switch (event.type) {
+      case "page_view" /* PAGE_VIEW */:
+        baseEvent.custom_data = {};
+        break;
+      case "product_view" /* PRODUCT_VIEW */:
+        const productEvent = event;
+        baseEvent.custom_data = {
+          content_type: "product_group",
+          content_ids: [productEvent.productId],
+          content_name: productEvent.productName,
+          content_category: productEvent.event_category,
+          value: productEvent.price,
+          currency: productEvent.currency || "INR"
+        };
+        break;
+      case "add_to_cart" /* ADD_TO_CART */:
+        const cartEvent = event;
+        baseEvent.custom_data = {
+          content_type: "product_group",
+          content_ids: [cartEvent.productId],
+          content_name: cartEvent.productName,
+          value: cartEvent.price,
+          currency: cartEvent.currency || "INR"
+        };
+        break;
+      case "search" /* SEARCH */:
+        const searchEvent = event;
+        baseEvent.custom_data = {
+          search_string: searchEvent.searchTerm,
+          content_category: "product",
+          content_ids: searchEvent.content_ids || []
+        };
+        break;
+      default:
+        baseEvent.custom_data = {};
+        break;
+    }
+    return baseEvent;
+  }
+  /**
+   * Map internal event types to Facebook event names (matching PixelAdapter)
+   */
+  mapEventName(eventType) {
+    const eventMap = {
+      ["page_view" /* PAGE_VIEW */]: "PageView",
+      ["product_view" /* PRODUCT_VIEW */]: "ViewContent",
+      ["add_to_cart" /* ADD_TO_CART */]: "AddToCart",
+      ["search" /* SEARCH */]: "Search"
+    };
+    return eventMap[eventType] || "CustomEvent";
+  }
+};
+function createFacebookCAPIService(config) {
+  const accessToken = config?.accessToken || process.env.FACEBOOK_CAPI_ACCESS_TOKEN;
+  const pixelId = config?.pixelId || process.env.NEXT_PUBLIC_PIXEL_ID;
+  const testEventCode = config?.testEventCode || process.env.FACEBOOK_TEST_EVENT_CODE;
+  if (!accessToken || !pixelId) {
+    console.warn("Facebook CAPI: Missing access token or pixel ID");
+    return null;
+  }
+  return new FacebookCAPIService({
+    accessToken,
+    pixelId,
+    testEventCode
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AffiliateTracker,
@@ -3240,11 +3981,13 @@ init_subscriber();
   DEFAULT_CURRENCY,
   EventNames,
   EventType,
+  FacebookCAPIService,
   GoogleAdapter,
-  HARDCODED_HANDLE,
   KwikCheckoutAdapter,
   KwikPassAdapter,
   MoengageAdapter,
+  PRIMA_EXPERIMENT_COOKIES,
+  PRIMA_EXPERIMENT_COOKIE_NAMES,
   PixelAdapter,
   PostHogAdapter,
   ShopifyAdapter,
@@ -3252,12 +3995,17 @@ init_subscriber();
   captureAffiliateParams,
   clearAffiliateParams,
   createAdapterLogger,
+  createFacebookCAPIService,
   createLogger,
   eventPublisher,
   eventSubscriber,
+  generateEventId,
   getAffiliateParams,
   getAffiliateSource,
+  getBrowserInfo,
+  getExperimentParams,
   hasAffiliateData,
+  hasExperimentData,
   initTracking,
   initializeEventTracking,
   logger,