@newrelic/browser-agent 1.316.0 → 1.317.0-rc.0

package/dist/cjs/common/payloads/payloads.js

@@ -0,0 +1,127 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.canCapturePayload = canCapturePayload;
+exports.createStringAdders = createStringAdders;
+exports.isLikelyHumanReadable = isLikelyHumanReadable;
+exports.parseQueryString = parseQueryString;
+exports.truncateAsString = truncateAsString;
+var _stringify = require("../util/stringify");
+var _constants = require("../../features/ajax/constants");
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Determines whether payload data should be captured based on the capture mode setting,
+ * HTTP status code, and GraphQL error status.
+ * @param {string} captureMode - The capture mode setting ('none', 'all', or 'failures')
+ * @param {number} statusCode - The HTTP status code
+ * @param {boolean} hasGQLErrors - Whether the response contains GraphQL errors
+ * @returns {boolean} True if payload should be captured
+ */
+function canCapturePayload(captureMode, statusCode, hasGQLErrors) {
+  if (captureMode === _constants.CAPTURE_PAYLOAD_SETTINGS.ALL) return true;
+  if (!captureMode || captureMode === _constants.CAPTURE_PAYLOAD_SETTINGS.NONE) return false;
+
+  // Default "failures" mode
+  return statusCode === 0 || statusCode >= 400 || hasGQLErrors === true;
+}
+
+/**
+ * Parses a query string into an object of key-value pairs.
+ * @param {string} search a query string starting with "?" or without (ex. new URL(...).search)
+ * @returns {Object|undefined} Parsed query parameters as key-value pairs. Returns undefined if no valid parameters are found.
+ */
+function parseQueryString(search) {
+  if (!search || search.length === 0) return;
+  const queryParams = {};
+  try {
+    const searchParams = new URLSearchParams(search);
+    searchParams.forEach(function (value, key) {
+      queryParams[key] = value;
+    });
+  } catch (e) {
+    // Fallback for environments without URLSearchParams
+  }
+  return queryParams;
+}
+
+/**
+ * Determines if the given content type is likely to be human-readable (text-based).
+ * @param {Object} headers - The headers object containing content-type
+ * @param {*} data - The data to check
+ * @returns {boolean} True if the content type is human-readable (text-based)
+ */
+function isLikelyHumanReadable(headers, data) {
+  if (!headers) return typeof data === 'string';
+  var contentType = headers['content-type'];
+  if (!contentType) return typeof data === 'string';
+  // Normalize to lowercase and extract the mime type (ignore charset, etc.)
+  var mimeType = contentType.toLowerCase().split(';')[0].trim();
+
+  // Check for text/* types
+  if (mimeType.indexOf('text/') === 0) return true;
+
+  // Check for specific application/* types
+  var readableAppTypes = ['/json', '/xml', '/xhtml+xml', '/ld+json', '/yaml', '/x-www-form-urlencoded'];
+  for (var i = 0; i < readableAppTypes.length; i++) {
+    if (mimeType === 'application' + readableAppTypes[i]) return true;
+  }
+  return false;
+}
+
+/**
+ * Truncates a string to ensure its UTF-8 byte length does not exceed 4092 bytes.  If truncation is necessary,
+ * the string is cut off at a character boundary to avoid breaking multi-byte characters and " ..." is appended to indicate truncation.
+ * If not a string, it is first converted to a string using JSON.stringify.
+ * @param {*} data The data to truncate.
+ * @returns {string}
+ */
+function truncateAsString(data) {
+  if (!data) return data;
+  try {
+    if (typeof data !== 'string') data = (0, _stringify.stringify)(data);
+    let bytes = 0;
+    let i = 0;
+    let needsEllipsis = false;
+    while (i < data.length) {
+      const c = data.charCodeAt(i);
+      const charBytes = c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0xD800 || c >= 0xE000 ? 3 : 4;
+      if (bytes + charBytes > 4092) {
+        needsEllipsis = true;
+        break;
+      }
+      bytes += charBytes;
+      i += charBytes === 4 ? 2 : 1;
+    }
+    return data.slice(0, i) + (needsEllipsis ? ' ...' : '');
+  } catch (e) {
+    return data;
+  }
+}
+
+/**
+ * Creates string adder functions for BEL serialization with obfuscation and optional truncation.
+ * This ensures a single string table is used while providing separate handling for regular vs payload attributes.
+ * @param {Function} getAddStringContext - Function that creates a new string table context
+ * @param {Object} obfuscator - Optional obfuscator instance for string obfuscation
+ * @returns {{addString: Function, addStringWithTruncation: Function}} Object containing both string adder functions
+ */
+function createStringAdders(getAddStringContext, obfuscator) {
+  const addStringRaw = getAddStringContext();
+  const processString = (str, shouldTruncate) => {
+    if (typeof str === 'undefined' || str === '') return addStringRaw(str);
+    if (typeof str !== 'string') str = (0, _stringify.stringify)(str);
+    const obfuscated = obfuscator?.obfuscateString(str) ?? str;
+    const processed = shouldTruncate ? truncateAsString(obfuscated) : obfuscated;
+    return addStringRaw(processed);
+  };
+  return {
+    addString: str => processString(str, false),
+    addStringWithTruncation: str => processString(str, true)
+  };
+}

package/dist/cjs/common/serialize/bel-serializer.js

@@ -9,7 +9,7 @@ exports.nullable = nullable;
 exports.numeric = numeric;
 var _stringify = require("../util/stringify");
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -24,13 +24,14 @@ function numeric(n, noDefault) {
   }
   return n === undefined || n === 0 ? '' : Math.floor(n).toString(36);
 }
-function getAddStringContext(obfuscator) {
+function getAddStringContext(obfuscator, truncator) {
   let stringTableIdx = 0;
   const stringTable = Object.prototype.hasOwnProperty.call(Object, 'create') ? Object.create(null) : {};
   return addString;
   function addString(str) {
     if (typeof str === 'undefined' || str === '') return '';
-    str = obfuscator.obfuscateString(String(str));
+    str = obfuscator?.obfuscateString(String(str)) ?? String(str);
+    str = truncator?.(str) ?? str;
     if (hasOwnProp.call(stringTable, str)) {
       return numeric(stringTable[str], true);
     } else {

package/dist/cjs/common/session/session-entity.js

@@ -17,30 +17,31 @@ var _handle = require("../event-emitter/handle");
 var _constants2 = require("../../features/metrics/constants");
 var _features = require("../../loaders/features/features");
 var _eventListenerOpts = require("../event-listener/event-listener-opts");
-var _constants3 = require("../../features/logging/constants");
 /**
  * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
-// this is what can be stored in local storage (not enforced but probably should be)
+// this is what can be stored in local storage (enforced during reads)
 // these values should sync between local storage and the parent class props
 const model = {
   value: '',
   inactiveAt: 0,
   expiresAt: 0,
   updatedAt: Date.now(),
-  sessionReplayMode: _constants.MODE.OFF,
+  sessionReplayMode: null,
   sessionReplaySentFirstChunk: false,
-  sessionTraceMode: _constants.MODE.OFF,
+  sessionTraceMode: null,
   traceHarvestStarted: false,
-  loggingMode: _constants3.LOGGING_MODE.OFF,
-  logApiMode: _constants3.LOGGING_MODE.OFF,
+  loggingMode: null,
+  logApiMode: null,
   serverTimeDiff: null,
   // set by TimeKeeper; "undefined" value will not be stringified and stored but "null" will
   custom: {},
   numOfResets: 0,
-  consent: false // set by consent() API call
+  consent: false,
+  // set by consent() API call
+  cachedRumResponse: null
 };
 class SessionEntity {
   /**
@@ -252,7 +253,6 @@ class SessionEntity {
       this.expiresTimer?.clear?.();
       delete this.isNew;
       this.setup({
-        agentRef: this.agentRef,
         key: this.key,
         storage: this.storage,
         expiresMs: this.expiresMs,

package/dist/cjs/common/util/data-size.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.dataSize = dataSize;
 var _stringify = require("./stringify");
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -17,7 +17,7 @@ var _stringify = require("./stringify");
  * @returns {(number|undefined)} - The size of the data or undefined if size cannot be determined.
  */
 function dataSize(data) {
-  if (typeof data === 'string' && data.length) return data.length;
+  if (typeof data === 'string') return data.length;
   if (typeof data !== 'object') return undefined;
   // eslint-disable-next-line
   if (typeof ArrayBuffer !== 'undefined' && data instanceof ArrayBuffer && data.byteLength) return data.byteLength;

package/dist/cjs/common/util/obfuscate.js

@@ -7,7 +7,7 @@ exports.Obfuscator = void 0;
 var _protocol = require("../url/protocol");
 var _console = require("./console");
 /**
- * Copyright 2020-2025 New Relic, Inc. All rights reserved.
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -16,6 +16,7 @@ var _console = require("./console");
  * @typedef {object} ObfuscationRule
  * @property {string|RegExp} regex The regular expression to match against in the payload
  * @property {string} [replacement] The string to replace the matched regex with
+ * @property {string[]} [eventFilter] An optional list of event types to which this rule should be applied. If not provided, or an empty array, the rule will be applied to all events.
  */
 
 /**
@@ -30,14 +31,33 @@ var _console = require("./console");
  */
 
 class Obfuscator {
-  constructor(agentRef) {
+  /**
+   * @param {Object} agentRef - Reference to the agent instance
+   * @param {string} [eventType] - Optional event type this obfuscator instance handles.
+   *                               If provided, only rules matching this event type (or rules with no eventFilter) will be applied.
+   */
+  constructor(agentRef, eventType) {
     this.agentRef = agentRef;
+    this.eventType = eventType;
     this.warnedRegexMissing = false;
     this.warnedInvalidRegex = false;
     this.warnedInvalidReplacement = false;
   }
   get obfuscateConfigRules() {
-    return this.agentRef.init.obfuscate || [];
+    const allRules = this.agentRef.init.obfuscate || [];
+
+    // If this instance has no specific event type, return all rules
+    if (!this.eventType) return allRules;
+
+    // Filter rules to only those that apply to this instance's event type
+    return allRules.filter(rule => {
+      // If rule has no eventFilter, it applies to all events
+      if (!this.#hasValidEventFilter(rule)) {
+        return true;
+      }
+      // Otherwise, check if this instance's event type matches the rule's filter
+      return rule.eventFilter.includes(this.eventType);
+    });
   }
 
   /**
@@ -63,6 +83,130 @@ class Obfuscator {
     }, input);
   }
 
+  /**
+   * Traverses an object and obfuscates all string properties.
+   * This instance will only apply rules that match its configured event type (if any).
+   * For features with mixed event types in their payloads (like generic_events), this will
+   * traverse the object and check each object's eventType property against the rules.
+   * @param {Object|Array} obj - The object or array to traverse
+   * @returns {Object|Array} The modified object
+   */
+  traverseAndObfuscateEvents(obj) {
+    if (!obj || typeof obj !== 'object') return obj;
+
+    // If this instance was configured with a specific event type, obfuscate everything
+    // (rules are already filtered in obfuscateConfigRules getter)
+    if (this.eventType) {
+      this.#applyFnToAllStrings(obj, this.obfuscateString.bind(this));
+      return obj;
+    }
+
+    // For generic obfuscators (no specific event types), check individual eventType properties
+    // This path is for features like generic_events that handle multiple event types
+    const eventTypesToObfuscate = new Set();
+    const globalRules = [];
+    const eventSpecificRules = [];
+    this.obfuscateConfigRules.forEach(rule => {
+      if (this.#hasValidEventFilter(rule)) {
+        eventSpecificRules.push(rule);
+        rule.eventFilter.forEach(eventType => eventTypesToObfuscate.add(eventType));
+      } else {
+        globalRules.push(rule);
+      }
+    });
+
+    // Optimization: if ALL rules are global (no event-specific rules exist),
+    // we can just apply all rules to everything without checking eventType properties
+    if (eventSpecificRules.length === 0) {
+      this.#applyFnToAllStrings(obj, this.obfuscateString.bind(this));
+      return obj;
+    }
+
+    // We have a mix of global and event-specific rules:
+    // - Apply event-specific rules only to matching eventTypes
+    // - Apply global rules to ALL event types
+    this.#applyFnWithEventTypeFilter(obj, this.obfuscateString.bind(this), Array.from(eventTypesToObfuscate), globalRules, null);
+    return obj;
+  }
+
+  /**
+   * Recursively applies a function to all string properties in an object.
+   * @param {Object|Array} obj - The object or array to traverse
+   * @param {Function} fn - The function to apply to string properties
+   * @private
+   */
+  #applyFnToAllStrings(obj, fn) {
+    if (!obj || typeof obj !== 'object') return;
+    Object.keys(obj).forEach(property => {
+      const value = obj[property];
+      if (typeof value === 'object' && value !== null) {
+        this.#applyFnToAllStrings(value, fn);
+      } else if (typeof value === 'string') {
+        obj[property] = fn(value);
+      }
+    });
+  }
+
+  /**
+   * Recursively applies a function to string properties based on eventType filtering.
+   * @param {Object|Array} obj - The object or array to traverse
+   * @param {Function} fn - The function to apply to string properties (applies all rules)
+   * @param {string[]} eventTypes - Array of event types to apply event-specific obfuscation
+   * @param {Array} globalRules - Rules without eventFilter that apply to all events
+   * @param {boolean|null} shouldObfuscate - Track obfuscation state: null = not determined yet, true = obfuscate with all rules, false = obfuscate with global rules only
+   * @private
+   */
+  #applyFnWithEventTypeFilter(obj, fn, eventTypes, globalRules, shouldObfuscate) {
+    if (!obj || typeof obj !== 'object') return;
+
+    // Determine the obfuscation state for this object
+    let currentShouldObfuscate = shouldObfuscate;
+
+    // Check if this object has an eventType property
+    if ('eventType' in obj && typeof obj.eventType === 'string') {
+      currentShouldObfuscate = eventTypes.includes(obj.eventType);
+    }
+
+    // Process all properties
+    Object.keys(obj).forEach(property => {
+      const value = obj[property];
+      if (typeof value === 'object' && value !== null) {
+        // Recursively traverse objects/arrays, passing the current obfuscation state
+        this.#applyFnWithEventTypeFilter(value, fn, eventTypes, globalRules, currentShouldObfuscate);
+      } else if (typeof value === 'string') {
+        if (currentShouldObfuscate === true) {
+          // Apply all rules (both global and event-specific)
+          obj[property] = fn(value);
+        } else if (currentShouldObfuscate === false && globalRules.length > 0) {
+          // Apply only global rules
+          obj[property] = this.#applyRulesToString(value, globalRules);
+        }
+        // If currentShouldObfuscate is null, we haven't found an eventType yet, so don't obfuscate
+      }
+    });
+  }
+
+  /**
+   * Applies specific obfuscation rules to a string.
+   * @param {string} input - The string to obfuscate
+   * @param {Array} rules - The rules to apply
+   * @returns {string} The obfuscated string
+   * @private
+   */
+  #applyRulesToString(input, rules) {
+    if (typeof input !== 'string' || input.trim().length === 0) return input;
+    const validatedRules = rules.map(rule => this.validateObfuscationRule(rule));
+    return validatedRules.filter(ruleValidation => ruleValidation.isValid).reduce((input, ruleValidation) => {
+      const {
+        rule
+      } = ruleValidation;
+      return input.replace(rule.regex, rule.replacement || '*');
+    }, input);
+  }
+  #hasValidEventFilter(rule) {
+    return Array.isArray(rule?.eventFilter) && rule.eventFilter.length > 0;
+  }
+
   /**
    * Validates an obfuscation rule and provides errors if any are found.
    * @param {ObfuscationRule} rule The rule to validate

package/dist/cjs/common/v2/mfe-vitals.js

@@ -0,0 +1,286 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.trackMFEVitals = trackMFEVitals;
+var _runtime = require("../constants/runtime");
+var _now = require("../timing/now");
+var _cleanUrl = require("../url/clean-url");
+/**
+ * Copyright 2020-2026 New Relic, Inc. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * @typedef {import('./register-api-types').RegisterAPITimings} RegisterAPITimings
+ */
+
+/**
+ * Generate a simple CSS selector for an element
+ * @param {Element} elem - The element to generate selector for
+ * @returns {string|null} CSS selector or null if element is invalid
+ */
+const getElementSelector = elem => {
+  try {
+    if (!elem || !elem.tagName) return null;
+    let selector = elem.tagName.toLowerCase();
+    if (elem.id) selector += "#".concat(elem.id);else if (elem.className && typeof elem.className === 'string') {
+      const classes = elem.className.trim().split(/\s+/).slice(0, 2).join('.');
+      if (classes) selector += ".".concat(classes);
+    }
+    return selector;
+  } catch (e) {
+    return null;
+  }
+};
+
+/**
+ * Extract URL from an element (for images, videos, etc.)
+ * @param {Element} elem - The element to extract URL from
+ * @returns {string|null} Cleaned URL or null
+ */
+const getElementURL = elem => {
+  try {
+    if (!elem) return null;
+
+    // For images and videos
+    if (elem.src) return (0, _cleanUrl.cleanURL)(elem.src);
+
+    // For elements with background images
+    const bgImage = _runtime.globalScope.getComputedStyle?.(elem)?.backgroundImage;
+    if (bgImage && bgImage !== 'none') {
+      const match = bgImage.match(/url\(['"]?([^'"]+)['"]?\)/);
+      if (match?.[1]) return (0, _cleanUrl.cleanURL)(match[1]);
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+};
+const isObservable = node => {
+  try {
+    return node?.textContent?.trim() || ['img', 'video', 'canvas', 'svg'].includes(node?.nodeName?.toLowerCase());
+  } catch (e) {
+    return false;
+  }
+};
+
+/**
+ * Check if node is within a specific MFE
+ * @param {Node} node - DOM node to check
+ * @param {string} id - MFE ID to match
+ * @returns {boolean}
+ */
+const isInMFE = (node, id) => {
+  try {
+    let curr = node.nodeType === 1 ? node : node.parentElement;
+    while (curr?.tagName) {
+      if (curr.dataset?.nrMfeId === id) return true;
+      curr = curr.parentNode;
+    }
+  } catch (e) {}
+  return false;
+};
+
+/**
+ * Create mutation observer for MFE nodes
+ * @param {string} id - MFE ID to track
+ * @param {Function} onMatch - Callback when matching node is added
+ * @returns {MutationObserver}
+ */
+const observeMutations = (id, onMatch) => {
+  const obs = new _runtime.globalScope.MutationObserver(mutations => {
+    mutations.forEach(m => m.addedNodes.forEach(node => {
+      if (isObservable(node) && isInMFE(node, id)) {
+        onMatch(node, obs);
+      }
+    }));
+  });
+  obs.observe(_runtime.globalScope.document, {
+    childList: true,
+    subtree: true
+  });
+  return obs;
+};
+
+/**
+ * Create performance observer for MFE entries
+ * @param {Array} observers - Array to track observers
+ * @param {Object} config - Observer configuration
+ * @param {Function} onEntry - Callback for each entry
+ * @returns {PerformanceObserver|null} Observer if successful, null if unsupported
+ */
+const observePerformance = (observers, config, onEntry) => {
+  try {
+    const obs = new _runtime.globalScope.PerformanceObserver(list => {
+      list.getEntries().forEach(onEntry);
+    });
+    obs.observe(config);
+    observers.push(obs);
+    return obs;
+  } catch (e) {
+    return null;
+  }
+};
+
+/**
+ * Tracks all Core Web Vitals for a specific MFE.
+ * @param {string} id - The MFE ID to track
+ * @returns {{fcp: object|null, lcp: object|null, cls: object|null, inp: object|null, disconnect: Function}}
+ */
+function trackMFEVitals(id) {
+  const vitals = {
+    fcp: null,
+    lcp: null,
+    cls: null,
+    inp: null,
+    disconnect: () => {}
+  };
+  if (!id || !_runtime.isBrowserScope || !_runtime.globalScope.MutationObserver || !_runtime.globalScope.PerformanceObserver) return vitals;
+  const observers = [];
+
+  // Track FCP - first contentful paint
+  observeMutations(id, (node, obs) => {
+    if (vitals.fcp === null) {
+      vitals.fcp = {
+        value: (0, _now.now)(),
+        loadState: _runtime.globalScope.document?.readyState || null
+      };
+      obs.disconnect();
+    }
+  });
+
+  // Track LCP - largest contentful paint
+  let largestSize = 0;
+  const lcpObs = observeMutations(id, node => {
+    try {
+      const elem = node.nodeType === 1 ? node : node.parentElement;
+      if (!elem) return;
+      const rect = elem.getBoundingClientRect();
+      const size = rect.width * rect.height;
+      if (size > largestSize) {
+        largestSize = size;
+        vitals.lcp = {
+          value: (0, _now.now)(),
+          size,
+          elTag: elem.tagName || null,
+          eid: elem.id || null,
+          elUrl: getElementURL(elem)
+        };
+      }
+    } catch (e) {
+      // Element may be detached from DOM
+    }
+  });
+  observers.push(lcpObs);
+
+  // Track CLS - cumulative layout shift
+  // Initialize CLS to 0 if browser supports it AND the MFE container exists in the DOM
+  let clsValue = 0;
+  const clsObs = observePerformance(observers, {
+    type: 'layout-shift',
+    buffered: true
+  }, entry => {
+    if (entry.hadRecentInput || !vitals.cls) return;
+    (entry.sources || []).some(source => {
+      if (isInMFE(source.node, id)) {
+        clsValue += entry.value;
+        vitals.cls ??= {
+          value: 0,
+          largestShiftValue: null,
+          largestShiftTime: null,
+          largestShiftTarget: null,
+          loadState: null
+        };
+        vitals.cls.value = clsValue;
+
+        // Track largest shift
+        if (entry.value > (vitals.cls.largestShiftValue || 0)) {
+          vitals.cls.largestShiftValue = entry.value;
+          vitals.cls.largestShiftTime = entry.startTime;
+          vitals.cls.largestShiftTarget = getElementSelector(source.node);
+          vitals.cls.loadState = _runtime.globalScope.document?.readyState || null;
+        }
+        return true;
+      }
+      return false;
+    });
+  });
+  if (clsObs) {
+    try {
+      const mfeContainer = _runtime.globalScope.document?.querySelector("[data-nr-mfe-id=\"".concat(id, "\"]"));
+      if (mfeContainer) {
+        vitals.cls ??= {
+          value: 0,
+          largestShiftValue: null,
+          largestShiftTime: null,
+          largestShiftTarget: null,
+          loadState: null
+        };
+      }
+    } catch (e) {
+      // querySelector may fail, leave CLS as null
+    }
+  }
+
+  // Track INP - interaction to next paint
+  observePerformance(observers, {
+    type: 'event',
+    buffered: true,
+    durationThreshold: 16
+  }, entry => {
+    if (!entry.interactionId || !entry.target || !isInMFE(entry.target, id)) return;
+    if (vitals.inp === null || entry.duration > vitals.inp.value) {
+      vitals.inp = {
+        value: entry.duration,
+        interactionTarget: getElementSelector(entry.target),
+        interactionTime: entry.startTime,
+        interactionType: entry.name,
+        inputDelay: entry.processingStart ? entry.processingStart - entry.startTime : null,
+        processingDuration: entry.processingStart && entry.processingEnd ? entry.processingEnd - entry.processingStart : null,
+        presentationDelay: entry.processingEnd && entry.duration ? entry.duration - (entry.processingEnd - entry.startTime) : null,
+        nextPaintTime: entry.startTime + entry.duration,
+        loadState: _runtime.globalScope.document?.readyState || null
+      };
+    }
+  });
+
+  // Disconnect all observers
+  vitals.disconnect = () => {
+    // Disconnect all observers
+    observers.forEach(obs => {
+      try {
+        obs?.disconnect();
+      } catch (e) {
+        // Observer may already be disconnected
+      }
+    });
+  };
+
+  // Auto-disconnect LCP observer on user interaction (per Web Vitals spec)
+  // CLS and INP continue tracking until visibility change or deregister
+  const disconnectLCP = () => {
+    try {
+      lcpObs?.disconnect();
+    } catch (e) {
+      // Observer may already be disconnected
+    }
+  };
+  ['click', 'keydown', 'scroll'].forEach(type => {
+    _runtime.globalScope.addEventListener(type, disconnectLCP, {
+      once: true,
+      passive: true
+    });
+  })
+
+  // Disconnect all observers on visibility change or page unload
+  ;
+  ['visibilitychange', 'pagehide'].forEach(type => {
+    _runtime.globalScope.addEventListener(type, vitals.disconnect, {
+      once: true,
+      passive: true
+    });
+  });
+  return vitals;
+}