@compilacion/colleciones-clientos 2.0.29 → 2.0.32

package/dist/browser.domainModel.gtm.config.sandbox.js

@@ -10,12 +10,13 @@ var collecionesClientosGtmConfigSandbox = (function (exports) {
             'trackerName': 'trackerName',
             'appName': 'appName',
             'emitterEndpoint': 'emitterEndpoint',
+            'errorLoggingEndpoint': 'errorLoggingEndpoint',
             'typeName': 'type'
         },
         'typeCastGtmVariableConfig': 'compilacionCollecionesClientosGtmTypeCastConfig'
     };
 
-    function getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrlInput) {    
+    function getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrlInput, errorLoggingEndpoint) {
         let returnObject = {};
         returnObject[constants.config.typeName] = constants.typeCastGtmVariableConfig;
         returnObject[constants.config.emitterEndpoint] = endpoint;
@@ -25,9 +26,12 @@ var collecionesClientosGtmConfigSandbox = (function (exports) {
         returnObject[constants.config.appName] = appName;
         returnObject[constants.config.sourceName] = jsLibSource;
         returnObject[constants.config.jsLibUrlVariable] = jsLibUrlInput;
+        // Optional: providing the URL of the server-side error-logging endpoint is what
+        // turns frontend error forwarding on. When left empty the runtime stays silent.
+        returnObject[constants.config.errorLoggingEndpoint] = errorLoggingEndpoint;
         return returnObject;
     }
-    /* return getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrl);*/
+    /* return getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrl, errorLoggingEndpoint);*/
 
     exports.getConfigObject = getConfigObject;
 

package/dist/browser.domainModel.gtm.config.sandbox.js.map

@@ -1 +1 @@
-{"version":3,"file":"browser.domainModel.gtm.config.sandbox.js","sources":["../src/browser.domainModel.gtm.constants.js","../src/browser.domainModel.gtm.config.sandbox.js"],"sourcesContent":["var constants = {\n    'sharedWindowObjectNames': {\n        'queue': 'compilacionCollecionesClientosGtmQueue',\n        'configVariable': 'compilacionCollecionesClientosGtmTypeCastConfig'\n    },\n    'config': {\n        'sourceName': 'jsLibSource',\n        'jsLibUrlVariable': 'jsLibSource_selfHostedUrl',\n        'selfHostedValue': 'SELF',\n        'unpkgHostedValue': 'UNPKG',\n        'flushInterval': 'flushInterval',\n        'flushSize': 'flushSize',\n        'trackerName': 'trackerName',\n        'appName': 'appName',\n        'emitterEndpoint': 'emitterEndpoint',\n        'typeName': 'type'\n    },\n    'collecionesObject': 'compilacionCollecionesClientosGtm',\n    'typeCastGtmVariableConfig': 'compilacionCollecionesClientosGtmTypeCastConfig'\n};\n\nexport default constants;","import constants from './browser.domainModel.gtm.constants.js';\n\nexport function getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrlInput) {    \n    let jsLibUrl = null;\n    if(jsLibSource === constants.config.unpkgHostedValue) {\n        jsLibUrl = \"https://unpkg.com/@compilacion/colleciones-clientos@latest/dist/browser.gtm.min.js\";\n    } else if (jsLibSource === constants.config.selfHostedValue) {\n        jsLibUrl = jsLibUrlInput\n    }\n    let returnObject = {};\n    returnObject[constants.config.typeName] = constants.typeCastGtmVariableConfig;\n    returnObject[constants.config.emitterEndpoint] = endpoint;\n    returnObject[constants.config.flushInterval] = flushInterval;\n    returnObject[constants.config.flushSize] = flushSize;\n    returnObject[constants.config.trackerName] = trackerName;\n    returnObject[constants.config.appName] = appName;\n    returnObject[constants.config.sourceName] = jsLibSource;\n    returnObject[constants.config.jsLibUrlVariable] = jsLibUrlInput;\n    return returnObject;\n}\n/* return getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrl);*/"],"names":[],"mappings":";;;IAAA,IAAI,SAAS,GAAG;IAChB,IAII,QAAQ,EAAE;IACd,QAAQ,YAAY,EAAE,aAAa;IACnC,QAAQ,kBAAkB,EAAE,2BAA2B;IACvD,QAEQ,eAAe,EAAE,eAAe;IACxC,QAAQ,WAAW,EAAE,WAAW;IAChC,QAAQ,aAAa,EAAE,aAAa;IACpC,QAAQ,SAAS,EAAE,SAAS;IAC5B,QAAQ,iBAAiB,EAAE,iBAAiB;IAC5C,QAAQ,UAAU,EAAE;IACpB,KAAK;IACL,IACI,2BAA2B,EAAE;IACjC,CAAC;;ICjBM,SAAS,eAAe,CAAC,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE;IAOtH,IAAI,IAAI,YAAY,GAAG,EAAE;IACzB,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,yBAAyB;IACjF,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,QAAQ;IAC7D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,aAAa;IAChE,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,SAAS;IACxD,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,WAAW;IAC5D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,OAAO;IACpD,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,WAAW;IAC3D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,aAAa;IACnE,IAAI,OAAO,YAAY;IACvB;IACA;;;;;;;;;;"}
+{"version":3,"file":"browser.domainModel.gtm.config.sandbox.js","sources":["../src/browser.domainModel.gtm.constants.js","../src/browser.domainModel.gtm.config.sandbox.js"],"sourcesContent":["var constants = {\n    'sharedWindowObjectNames': {\n        'queue': 'compilacionCollecionesClientosGtmQueue',\n        'configVariable': 'compilacionCollecionesClientosGtmTypeCastConfig'\n    },\n    'config': {\n        'sourceName': 'jsLibSource',\n        'jsLibUrlVariable': 'jsLibSource_selfHostedUrl',\n        'selfHostedValue': 'SELF',\n        'unpkgHostedValue': 'UNPKG',\n        'flushInterval': 'flushInterval',\n        'flushSize': 'flushSize',\n        'trackerName': 'trackerName',\n        'appName': 'appName',\n        'emitterEndpoint': 'emitterEndpoint',\n        'errorLoggingEndpoint': 'errorLoggingEndpoint',\n        'typeName': 'type'\n    },\n    'collecionesObject': 'compilacionCollecionesClientosGtm',\n    'typeCastGtmVariableConfig': 'compilacionCollecionesClientosGtmTypeCastConfig'\n};\n\nexport default constants;","import constants from './browser.domainModel.gtm.constants.js';\n\nexport function getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrlInput, errorLoggingEndpoint) {\n    let jsLibUrl = null;\n    if(jsLibSource === constants.config.unpkgHostedValue) {\n        jsLibUrl = \"https://unpkg.com/@compilacion/colleciones-clientos@latest/dist/browser.gtm.min.js\";\n    } else if (jsLibSource === constants.config.selfHostedValue) {\n        jsLibUrl = jsLibUrlInput\n    }\n    let returnObject = {};\n    returnObject[constants.config.typeName] = constants.typeCastGtmVariableConfig;\n    returnObject[constants.config.emitterEndpoint] = endpoint;\n    returnObject[constants.config.flushInterval] = flushInterval;\n    returnObject[constants.config.flushSize] = flushSize;\n    returnObject[constants.config.trackerName] = trackerName;\n    returnObject[constants.config.appName] = appName;\n    returnObject[constants.config.sourceName] = jsLibSource;\n    returnObject[constants.config.jsLibUrlVariable] = jsLibUrlInput;\n    // Optional: providing the URL of the server-side error-logging endpoint is what\n    // turns frontend error forwarding on. When left empty the runtime stays silent.\n    returnObject[constants.config.errorLoggingEndpoint] = errorLoggingEndpoint;\n    return returnObject;\n}\n/* return getConfigObject(endpoint, flushInterval, flushSize, trackerName, appName, jsLibSource, jsLibUrl, errorLoggingEndpoint);*/"],"names":[],"mappings":";;;IAAA,IAAI,SAAS,GAAG;IAChB,IAII,QAAQ,EAAE;IACd,QAAQ,YAAY,EAAE,aAAa;IACnC,QAAQ,kBAAkB,EAAE,2BAA2B;IACvD,QAEQ,eAAe,EAAE,eAAe;IACxC,QAAQ,WAAW,EAAE,WAAW;IAChC,QAAQ,aAAa,EAAE,aAAa;IACpC,QAAQ,SAAS,EAAE,SAAS;IAC5B,QAAQ,iBAAiB,EAAE,iBAAiB;IAC5C,QAAQ,sBAAsB,EAAE,sBAAsB;IACtD,QAAQ,UAAU,EAAE;IACpB,KAAK;IACL,IACI,2BAA2B,EAAE;IACjC,CAAC;;IClBM,SAAS,eAAe,CAAC,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,oBAAoB,EAAE;IAO5I,IAAI,IAAI,YAAY,GAAG,EAAE;IACzB,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC,yBAAyB;IACjF,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,GAAG,QAAQ;IAC7D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,aAAa;IAChE,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,SAAS;IACxD,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,WAAW,CAAC,GAAG,WAAW;IAC5D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,OAAO;IACpD,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,WAAW;IAC3D,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,aAAa;IACnE;IACA;IACA,IAAI,YAAY,CAAC,SAAS,CAAC,MAAM,CAAC,oBAAoB,CAAC,GAAG,oBAAoB;IAC9E,IAAI,OAAO,YAAY;IACvB;IACA;;;;;;;;;;"}

package/dist/browser.domainModel.gtm.js

@@ -18,30 +18,6 @@
       }
   };
 
-  /**
-   * Collects browser-related context values like screen size, language, etc.
-   * Returns an empty object if not in browser environment.
-   * @returns {Object}
-   */
-  const getBrowserContext = function() {
-      if (typeof window === 'undefined' || typeof navigator === 'undefined') {
-          return {};
-      }
-      return {
-          hasFocus: document.hasFocus(),
-          language: navigator.language,
-          platform: navigator.platform,
-          referrer: document.referrer,
-          screenHeight: window.screen.height,
-          screenWidth: window.screen.width,
-          timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-          url: window.location.href,
-          userAgent: navigator.userAgent,
-          viewportHeight: window.innerHeight,
-          viewportWidth: window.innerWidth,
-      };
-  };
-
   const formatToCamelCase = function(input) {
     return input
       .replace(/[^a-zA-Z0-9]+/g, ' ')
@@ -259,6 +235,27 @@
           this.context[context] = value;
       }
 
+      /**
+       * Records a namespaced enrichment under `meta.enrichments`. A producer or
+       * processor the event passes through claims its own `name` ("I am X") and may
+       * declare what subject the data is `about` ("this tells something about Y"), so a
+       * model-aware consumer (e.g. the server) can map it onto entity state. Kept OUT
+       * of `context` on purpose: enrichments are transport/environment metadata, not
+       * part of the domain-validated event payload.
+       * @param {string} name - The enrichment namespace (the source identity).
+       * @param {string|string[]} about - The subject(s) the data describes (recommended).
+       * @param {*} data - The contributed payload.
+       */
+      setEnrichment = function(name, about, data) {
+          if (typeof name !== 'string') {
+              throw new Error('Enrichment name must be a string');
+          }
+          if (!this.meta.enrichments) {
+              this.meta.enrichments = {};
+          }
+          this.meta.enrichments[name] = { about, data };
+      }
+
       /**
        * Alias for `setReference` for compatibility.
        * Declares an external entity referenced by this event.
@@ -719,6 +716,44 @@
           this.emitters = emitters;
           this.trackerName = trackerName;
           this.appName = appName;
+          this.handlers = [];
+      }
+
+      /**
+       * Register an enrichment handler. A handler self-identifies (`name` — "I am X")
+       * and may declare what it is `about` (the subject(s) — "this tells about Y"); on
+       * track it contributes `collect(event)` into `meta.enrichments[name]`. An optional
+       * `appliesTo(event)` lets a handler contribute only for relevant events, and
+       * `collect` may return `null`/`undefined` to contribute nothing for this event.
+       * Handlers stay model-agnostic — `about` is a plain subject string (or array); a
+       * model-aware consumer (the server) does the actual mapping.
+       * @param {{name: string, about?: string|string[], collect: function, appliesTo?: function}} handler
+       * @returns {CollecionesTracker} this (chainable).
+       */
+      use(handler) {
+          if (!handler || typeof handler.name !== 'string' || typeof handler.collect !== 'function') {
+              throw new Error('Handler must have a string `name` and a `collect(event)` function');
+          }
+          this.handlers.push(handler);
+          return this;
+      }
+
+      /** Run every registered handler against the event, writing namespaced enrichments. */
+      runHandlers(collecionesEvent) {
+          this.handlers.forEach((handler) => {
+              try {
+                  if (typeof handler.appliesTo === 'function' && !handler.appliesTo(collecionesEvent)) {
+                      return;
+                  }
+                  const data = handler.collect(collecionesEvent);
+                  if (data === undefined || data === null) {
+                      return; // handler declined to contribute for this event
+                  }
+                  collecionesEvent.setEnrichment(handler.name, handler.about, data);
+              } catch (error) {
+                  // A failing handler must never drop the event; skip its enrichment.
+              }
+          });
       }
 
       /**
@@ -731,7 +766,8 @@
               throw new Error('Event must be of type CollecionesEvent');
           }
           collecionesEvent.setTracker(this.trackerName);
-          collecionesEvent.setAppName(this.appName); 
+          collecionesEvent.setAppName(this.appName);
+          this.runHandlers(collecionesEvent);
           this.emitters.forEach(element => {
               element.track(collecionesEvent, this.trackerName, this.appName);
           });
@@ -753,31 +789,236 @@
   }
 
   /**
-   * Web-specific tracker that enriches events with browser context before sending them.
-   * Extends the base CollecionesTracker.
+   * Default browser-context enrichment handler. Contributes the page/browser
+   * environment under `meta.enrichments.browserContext`.
+   *
+   * This is transport/environment metadata — deliberately NOT part of the
+   * domain-validated `context`. A model-aware consumer (the server) routes each field
+   * onto the matching attribute of one of the declared subjects. Returns an empty
+   * payload outside a browser.
+   */
+  const browserContextHandler = {
+      name: 'browserContext',
+      about: ['session', 'webpage', 'visitor'],
+      collect() {
+          if (typeof window === 'undefined' || typeof navigator === 'undefined') {
+              return {};
+          }
+          return {
+              hasFocus: document.hasFocus(),
+              language: navigator.language,
+              platform: navigator.platform,
+              referrer: document.referrer,
+              screenHeight: window.screen.height,
+              screenWidth: window.screen.width,
+              timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+              url: window.location.href,
+              userAgent: navigator.userAgent,
+              viewportHeight: window.innerHeight,
+              viewportWidth: window.innerWidth,
+          };
+      },
+  };
+
+  /**
+   * Marketing / attribution handler. Parses the page URL's query string for the
+   * standard UTM parameters and the common ad-network click identifiers, so the
+   * model-aware consumer (the server) can attribute the session/visitor.
+   *
+   * Declares `about: ['session', 'visitor']` — attribution describes entity state,
+   * not event payload. Returns `null` when the URL carries no marketing parameters,
+   * so the handler adds nothing on the (many) events that have none.
+   *
+   * Field names are the conventional analytics names the domain model also uses
+   * (`utmSource`, `marketingNetwork`, ...) — not domain-model coupling, just the
+   * shared vocabulary of web attribution.
+   */
+
+  // UTM query parameter -> conventional camelCase field name.
+  const UTM_FIELDS = [
+      ['utm_source', 'utmSource'],
+      ['utm_medium', 'utmMedium'],
+      ['utm_campaign', 'utmCampaign'],
+      ['utm_term', 'utmTerm'],
+      ['utm_content', 'utmContent'],
+  ];
+
+  // Known ad-network click identifiers, in resolution priority, mapped to their network.
+  const CLICK_ID_NETWORKS = [
+      ['gclid', 'google'],
+      ['wbraid', 'google'],
+      ['gbraid', 'google'],
+      ['dclid', 'google'],
+      ['msclkid', 'microsoft'],
+      ['fbclid', 'meta'],
+      ['igshid', 'meta'],
+      ['ttclid', 'tiktok'],
+      ['li_fat_id', 'linkedin'],
+      ['twclid', 'twitter'],
+      ['yclid', 'yandex'],
+      ['epik', 'pinterest'],
+      ['scid', 'snapchat'],
+  ];
+
+  const marketingHandler = {
+      name: 'marketing',
+      about: ['session', 'visitor'],
+      collect() {
+          if (typeof window === 'undefined' || !window.location) {
+              return null;
+          }
+          const params = new URLSearchParams(window.location.search || '');
+          const data = {};
+
+          UTM_FIELDS.forEach(([param, field]) => {
+              const value = params.get(param);
+              if (value) {
+                  data[field] = value;
+              }
+          });
+
+          for (const [param, network] of CLICK_ID_NETWORKS) {
+              const value = params.get(param);
+              if (value) {
+                  data.marketingNetwork = network;
+                  data.marketingNetworkClickId = value;
+                  break;
+              }
+          }
+
+          return Object.keys(data).length > 0 ? data : null;
+      },
+  };
+
+  /**
+   * UA Client Hints handler. Surfaces the low-entropy values from
+   * `navigator.userAgentData` (Chromium) — `mobile`, `platform`, `brands` — a more
+   * reliable device/browser signal than parsing the user-agent string server-side.
+   *
+   * Declares `about: ['visitor', 'session']`. Returns `null` where UA-CH is
+   * unavailable (Firefox/Safari) — the server then falls back to the user-agent
+   * string carried by `browserContext`. Only the synchronous low-entropy values are
+   * read; the async `getHighEntropyValues()` is intentionally not awaited.
+   */
+  const userAgentDataHandler = {
+      name: 'userAgentData',
+      about: ['visitor', 'session'],
+      collect() {
+          if (typeof navigator === 'undefined' || !navigator.userAgentData) {
+              return null;
+          }
+          const uaData = navigator.userAgentData;
+          const data = {
+              mobile: Boolean(uaData.mobile),
+          };
+          if (uaData.platform) {
+              data.platform = uaData.platform;
+          }
+          if (Array.isArray(uaData.brands) && uaData.brands.length > 0) {
+              data.brands = uaData.brands.map((b) => ({ brand: b.brand, version: b.version }));
+          }
+          return data;
+      },
+  };
+
+  /**
+   * Consent handler. Surfaces the synchronously-available consent signals: the IAB
+   * TCF consent string (from the `euconsent-v2` cookie), the detected CMP provider,
+   * and the Global Privacy Control signal. The model-aware consumer (the server)
+   * decodes the TCF string into granted categories.
+   *
+   * Declares `about: ['consent', 'session']`. Returns `null` when no consent signal
+   * is present. NOTE: only synchronous sources are read — the async `__tcfapi`
+   * in-memory state is intentionally not awaited; the persisted cookie is the
+   * source of truth.
+   */
+
+  // Known CMP globals -> provider name.
+  const CMP_PROVIDERS = [
+      ['Cookiebot', 'cookiebot'],
+      ['OneTrust', 'onetrust'],
+      ['Optanon', 'onetrust'],
+      ['Didomi', 'didomi'],
+      ['UC_UI', 'usercentrics'],
+  ];
+
+  function readCookie(name) {
+      if (typeof document === 'undefined' || typeof document.cookie !== 'string') {
+          return undefined;
+      }
+      const match = document.cookie.match(new RegExp('(?:^|; )' + name + '=([^;]*)'));
+      return match ? decodeURIComponent(match[1]) : undefined;
+  }
+
+  function detectProvider() {
+      if (typeof window === 'undefined') {
+          return undefined;
+      }
+      for (const [global, name] of CMP_PROVIDERS) {
+          if (window[global]) {
+              return name;
+          }
+      }
+      if (typeof window.__tcfapi === 'function') {
+          return 'iab-tcf';
+      }
+      return undefined;
+  }
+
+  const consentHandler = {
+      name: 'consent',
+      about: ['consent', 'session'],
+      collect() {
+          if (typeof window === 'undefined') {
+              return null;
+          }
+          const data = {};
+
+          const tcfConsentString = readCookie('euconsent-v2');
+          if (tcfConsentString) {
+              data.tcfConsentString = tcfConsentString;
+          }
+
+          const provider = detectProvider();
+          if (provider) {
+              data.consentProvider = provider;
+          }
+
+          if (typeof navigator !== 'undefined' && typeof navigator.globalPrivacyControl === 'boolean') {
+              data.globalPrivacyControl = navigator.globalPrivacyControl;
+          }
+
+          return Object.keys(data).length > 0 ? data : null;
+      },
+  };
+
+  /**
+   * The default enrichment handlers registered on every web tracker. Each handler is
+   * model-agnostic: it self-identifies (`name`), declares what it is `about` (subject
+   * strings) and `collect`s its data; a model-aware consumer maps it onto entity state.
+   */
+  const defaultWebHandlers = [
+      browserContextHandler,
+      marketingHandler,
+      userAgentDataHandler,
+      consentHandler,
+  ];
+
+  /**
+   * Web-specific tracker: the base tracker plus the default web enrichment handlers
+   * (browser context, marketing/attribution, UA client hints, consent), so every web
+   * event carries the client environment and attribution signals in
+   * `meta.enrichments` — never in the domain-validated `context`.
    */
   class CollecionesWebTracker extends CollecionesTracker {
       /**
-       * Creates a new instance of CollecionesWebTracker.
-       * @param {Array} emitters - A list of emitter instances used to send the event.
-       * @param {string} trackerName - The name of the tracker.
-       * @param {string} appName - The name of the application generating events.
+       * @param {Array} emitters - Emitter instances used to send events.
+       * @param {string} trackerName - The tracker name.
+       * @param {string} appName - The application generating events.
        */
       constructor(emitters, trackerName, appName) {
           super(emitters, trackerName, appName);
-      }
-
-      /**
-       * Tracks an event, enriching it with browser context information.
-       * @param {CollecionesEvent} collecionesEvent - The event object to track.
-       * @throws {Error} If the event is not an instance of CollecionesEvent.
-       */
-      track(collecionesEvent) {
-          if (!(collecionesEvent instanceof CollecionesEvent)) {
-              throw new Error('Event must be of type CollecionesEvent');
-          }
-          collecionesEvent.setContext('browserContext', getBrowserContext());
-          super.track(collecionesEvent);        
+          defaultWebHandlers.forEach((handler) => this.use(handler));
       }
   }
 
@@ -791,7 +1032,8 @@
           'flushSize': 'flushSize',
           'trackerName': 'trackerName',
           'appName': 'appName',
-          'emitterEndpoint': 'emitterEndpoint'},
+          'emitterEndpoint': 'emitterEndpoint',
+          'errorLoggingEndpoint': 'errorLoggingEndpoint'},
       'collecionesObject': 'compilacionCollecionesClientosGtm',
       'typeCastGtmVariableConfig': 'compilacionCollecionesClientosGtmTypeCastConfig'
   };
@@ -808,6 +1050,62 @@
           let queueReference = null;
           let processedQueueLength = 0;
 
+          // Identity/destination details captured from the GTM config so a caught error
+          // can be attributed (tracker/app) and forwarded to the right endpoint.
+          let appName = null;
+          let trackerName = null;
+          let errorLoggingEndpoint = null;
+
+          const safeStringify = (value) => {
+              if (value === undefined) return '';
+              if (typeof value === 'string') return value;
+              try {
+                  return JSON.stringify(value);
+              } catch (e) {
+                  return String(value);
+              }
+          };
+
+          // Forward a caught client-side error to the configured bad-event endpoint.
+          // The whole point of this is to make the try/catch fallbacks visible server-side,
+          // so it is strictly best-effort and must NEVER throw: a failure to report an
+          // error can not be allowed to break the tracking flow it is meant to protect.
+          // Reporting only happens when an errorLoggingEndpoint URL is configured.
+          const reportError = (error, details = {}) => {
+              if (!errorLoggingEndpoint) return;
+              if (typeof fetch !== 'function') return;
+              try {
+                  const payload = {
+                      errorName: (error && error.name) ? String(error.name) : 'Error',
+                      errorMessage: (error && error.message) ? String(error.message) : String(error),
+                      tracker: trackerName != null ? String(trackerName) : '',
+                      appName: appName != null ? String(appName) : '',
+                      entity: details.entity != null ? String(details.entity) : '',
+                      action: details.action != null ? String(details.action) : '',
+                      rawEvent: safeStringify(details.rawEvent),
+                      context: {
+                          // phase identifies which fallback caught the error: init, flush or group.
+                          phase: details.phase || '',
+                          stack: (error && error.stack) ? String(error.stack) : '',
+                          url: (typeof window !== 'undefined' && window.location) ? window.location.href : '',
+                          userAgent: (typeof navigator !== 'undefined' && navigator.userAgent) ? navigator.userAgent : '',
+                          language: (typeof navigator !== 'undefined' && navigator.language) ? navigator.language : '',
+                          clientTimestamp: new Date().toISOString()
+                      }
+                  };
+                  // keepalive lets a report fired during page unload still have a chance to land.
+                  fetch(errorLoggingEndpoint, {
+                      method: 'POST',
+                      credentials: 'include',
+                      keepalive: true,
+                      headers: { 'Content-Type': 'application/json' },
+                      body: JSON.stringify(payload)
+                  }).catch(() => {});
+              } catch (e) {
+                  // Swallow: error reporting can never be allowed to surface its own exception.
+              }
+          };
+
           let init = () => {
               if (initialized) return true;
               if (window[constants.sharedWindowObjectNames.configVariable] === undefined) return false;
@@ -815,8 +1113,11 @@
               if (config.type === undefined || config.type !== constants.typeCastGtmVariableConfig) return false;
               let flushInterval = config[constants.config.flushInterval];
               let flushSize = config[constants.config.flushSize];
-              let trackerName = config[constants.config.trackerName];
-              let appName = config[constants.config.appName];
+              trackerName = config[constants.config.trackerName];
+              appName = config[constants.config.appName];
+              // Capture the error endpoint as soon as a valid config is available so even an
+              // emitter-init failure below can already be reported.
+              errorLoggingEndpoint = config[constants.config.errorLoggingEndpoint] ?? null;
               let emitterEndpoint = config[constants.config.emitterEndpoint] ?? config.endpoint;
               try {
                   emitter = new CollecionesEmitter(emitterEndpoint, flushSize, flushInterval);
@@ -825,6 +1126,7 @@
                   return true;
               } catch (e) {
                   console.error('Error initializing CollecionesEmitter:', e);
+                  reportError(e, { phase: 'init' });
                   return false;
               }
           };
@@ -1059,6 +1361,12 @@
                           added++;
                       } catch (e) {
                           console.error('Colleciones: skipped malformed grouped event', e);
+                          reportError(e, {
+                              phase: 'group',
+                              rawEvent: eventArg,
+                              entity: eventArg?.entity,
+                              action: eventArg?.action
+                          });
                       }
                   });
                   if (added === 0) return false;
@@ -1078,7 +1386,7 @@
               return true;
           };
 
-          let flush = () => {
+          let flushInternal = () => {
               if (!init()) {
                   return;
               }
@@ -1103,10 +1411,32 @@
                       track(args);
                   } catch (e) {
                       console.error('Colleciones: failed to process queued event', e);
+                      reportError(e, {
+                          phase: 'flush',
+                          rawEvent: args,
+                          entity: args?.entity,
+                          action: args?.action
+                      });
                   }
               }
           };
 
+          // Overarching safety net. The per-event / per-group catches above exist for
+          // RECOVERY (they keep the loop alive), so they intentionally sit inside the loop.
+          // This wrapper catches everything else our own runtime can throw — init, queue
+          // bookkeeping, or any path we forgot to guard — so nothing fails silently again.
+          // It only fires for genuinely unhandled throws (the inner catches swallow theirs),
+          // so there is no double reporting. Scope is our runtime only: page-level errors
+          // from other scripts are deliberately not captured here.
+          let flush = () => {
+              try {
+                  flushInternal();
+              } catch (e) {
+                  console.error('Colleciones: unexpected runtime failure', e);
+                  reportError(e, { phase: 'runtime' });
+              }
+          };
+
           let ensureQueue = () => {
               let queue = window[constants.sharedWindowObjectNames.queue];
               if (!Array.isArray(queue)) {